Можете ли вы передать манипулятор в функцию?

У ваших манипуляторов может быть довольно много произвольных типов, поэтому вы должны использовать шаблоны для их обработки. Чтобы получить к ним доступ с помощью указателя или ссылки фиксированного типа, вам придется использовать общий базовый класс для всех этих шаблонов. Этот тип полиморфизма работает только для указателей и ссылок, но вам, вероятно, нужна семантика значений, особенно для хранения их в контейнерах. Так что самый простой способ это позволить shared_ptr позаботьтесь об управлении памятью и используйте другой класс, чтобы скрыть все неприятные детали от пользователя.

Результат может выглядеть так:

#include <memory>
#include <iostream>

// an abstract class to provide a common interface to all manipulators
class abstract_manip {
public:
virtual ~abstract_manip() { }
virtual void apply(std::ostream& out) const = 0;
};

// a wrapper template to let arbitrary manipulators follow that interface
template<typename M> class concrete_manip : public abstract_manip {
public:
concrete_manip(const M& manip) : _manip(manip) { }
void apply(std::ostream& out) const { out << _manip; }
private:
M _manip;
};

// a class to hide the memory management required for polymorphism
class smanip {
public:
template<typename M> smanip(const M& manip)
: _manip(new concrete_manip<M>(manip)) { }
template<typename R, typename A> smanip(R (&manip)(A))
: _manip(new concrete_manip<R (*)(A)>(&manip)) { }
void apply(std::ostream& out) const { _manip->apply(out); }
private:
std::shared_ptr<abstract_manip> _manip;
};

inline std::ostream& operator<<(std::ostream& out, const smanip& manip) {
manip.apply(out);
return out;
}

При этом ваш код работает после некоторых небольших изменений в пространствах имен:

void print(const std::vector<smanip>& manips) {
for (auto m : manips)
std::cout << m;
}

int main(int argc, const char** argv) {
print({std::fixed, std::setprecision(2)});
}

Поскольку манипуляторы являются функциями, это зависит от их сигнатуры. Это означает, что вы можете создать вектор манипуляторов с одинаковой подписью.

Например :

#include <iomanip>
#include <vector>
#include <iostream>

typedef std::ios_base& (*manipF)( std::ios_base& );

std::vector< manipF > getManipulators()
{
std::vector< manipF > m =
{
std::showpos,
std::boolalpha
};
return m;
}

int main()
{
auto m = getManipulators();

for ( auto& it : m )
{
std::cout<<it;
}
std::cout<<"hi " << true << 5.55555f << std::endl;
}

Альтернатива — использовать лямбды:

#include <iomanip>
#include <vector>
#include <iostream>
#include <functional>

typedef std::function< std::ios_base& ( std::ios_base& ) > manipF;

std::vector< manipF > getManipulators()
{
std::vector< manipF > m =
{
std::showpos,
std::boolalpha,
[] ( std::ios_base& )->std::ios_base&
{
std::cout << std::setprecision( 2 );
return std::cout;
}
};
return m;
}

int main()
{
auto m = getManipulators();

for ( auto& it : m )
{
it(std::cout);
}
std::cout<<"hi " << true << 5.55555f << std::endl;
}

Стандартное решение C ++ 17, может основываться на std :: tuple. Здесь находится P.O.C.

int main()
{
// quick p.o.c.
auto ios_mask_keeper = [&](auto mask) {
// keep tuple here
static auto mask_ = mask;
return mask_;
};

// make required ios mask and keep it
auto the_tuple = ios_mask_keeper(
// please note we can mix ios formaters and iomanip-ulators
std::make_tuple(std::boolalpha, std::fixed, std::setprecision(2) )
);

// apply iomanip's stored in a tuple
std::apply([&](auto & ...x)
{
// c++17 fold
(std::cout << ... << x);
}, the_tuple);

return 0;

}

Можно хранить кортеж в классе и т. Д. Работает как в компиляторе CL MSVC версии 19.14.26431.0, так и в обязательный Wand Box используя лязг