variadic-templates

template<class... Foos> // N = sizeof...(Foos) template<typename... Args> // M = sizeof...(Args) void split_and_call(Args&&... args) { // Using Python notation here... Foos[0](*args[:a]); // a = arity of Foos[0] Foos[1](*args[a:b]); // b-a = arity of Foos[1] ... Foos[N-1](*args[z:M]); // M-z = arity of Foos[N-1] } Assumptions: All types in Foos are callable All types in Foos are unambiguous Any type in Foos may have an arity of 0 Args is the concatenation of all of the argument types used by Foos Can this be done with just Foos and without Args ? I'm actually not sure how to do it even if I

The base class is : #include <memory> namespace cb{ template< typename R, typename ... Args > class CallbackBase { public: typedef std::shared_ptr< CallbackBase< R, Args... > > CallbackPtr; virtual ~CallbackBase() { } virtual R Call( Args ... args) = 0; }; } // namespace cb Derived class is this : namespace cb{ template< typename R, typename ... Args > class FunctionCallback : public CallbackBase< R, Args... > { public: typedef R (*funccb)(Args...); FunctionCallback( funccb cb_ ) : CallbackBase< R, Args... >(), cb( cb_ ) { } virtual ~FunctionCallback() { } virtual R Call(Args... args) { return

Sorry the title is a mouthful. I'm working on an array class similar to the one discussed here . I want to define a "map" function that takes a user-defined function and applies it to each element of the array. For the purposes of type-checking, I'd like to define it such that the user-specified function must take the same number of arguments as are passed to the map function, so that double f(double a, double b) { return a + b; } Array<double,2> x, y, z; x.map(f, y, z); will compile but double g(double a, double b, double c) { return a + b + c; } Array<double,2> x, y, z;. x.map(g, y, z); won

Here's a class with variadic constructor and it's specializations for copy and move from a temporary. template<class Obj> class wrapper { protected: Obj _Data; public: wrapper(const wrapper<Obj>& w): _Data(w._Data) {} wrapper(wrapper<Obj>&& w): _Data(std::forward<Obj>(w._Data)) {} template<class ...Args> wrapper(Args&&... args): _Data(std::forward<Args>(args)...) {} inline Obj& operator()() { return _Data; } virtual ~wrapper() {} }; When I use one of specializations like this wrapper<int> w1(9); wrapper<int> w2(w1); I'm getting the error: type of w1 is deduced as int . Output from VS2012:

I have an api that looks like this: template<typename... Args> Widget::Widget(std::string format_str, Args&&... args); How would you call this method if you have a vector of strings for 'args', i.e. the args length isn't known at compile time? What would the implementation of a wrapper function look like that would convert this to something like this? template<typename... Args> Widget::WrapperWidget(std::string format_str, vector<string>); Following may help: #if 1 // Not in C++11 #include <cstdint> template <std::size_t ...> struct index_sequence {}; template <std::size_t I, std::size_t ...Is

My title might be wrong - if so, please do correct me, but at some point its hard for me to keep track of what meta thingy I'm actually trying to achieve ;) I have a class function template like this: template<template<typename...> class MapType> Expression Expression::substitute(MapType<std::string, Expression> const& identifierToExpressionMap) const { return SubstitutionVisitor<MapType>(identifierToExpressionMap).substitute(something); } The important part is the MapType. The idea is to allow either std::map or std::unordered_map to be plugged in at will. With GCC and Clang, this works, but