c++03 : Variadic templates using boost

Question

I'm trying to find a workaround to use variadic templates within c++03.

What I would like to achieve is - within a templated class - instanciated a boost::tuple attribute, which would be composed of a vector for each single class template parameter.

This is how it would look like using c++11 variadic templates:

template<typename ...Parameters>
class Foo
{
   typedef std::tuple<std::vector<Parameters>...> Vectors_t;

   Vectors_t _vectorsTuple;
}

I would like to achieve the same using boost::tuple and boost::mpl or whatever other possible ways.

Thanks

UPDATE

This is the final solution I came up with. Partly based on @stefanmoosbrugger proposition.

template<class TypesList>
class FooImpl
{
    typedef TypesList TypesList_t;
    typedef typename boost::mpl::transform <
      TypesList_t,
      std::vector<boost::mpl::_1>
      >::type VectorTypesList_t;
    typedef typename boost::mpl::reverse_fold<
      VectorTypesList_t,
      boost::tuples::null_type,
      boost::tuples::cons<boost::mpl::_2, boost::mpl::_1>
      >::type VectorsTuple_t;

     protected:
         VectorsTuple_t _vectorsTuple;
};

template<class Type1, 
         class Type2 = boost::mpl::na, 
         class Type3 = boost::mpl::na,
         class Type4 = boost::mpl::na> /* Made it up to four possible types as an example */ 
class Foo : public FooImpl<boost::mpl::vector<Type1, Type2, Type3, Type4> >{};

Stefan Moosbrugger · Accepted Answer · 2016-11-19T10:00:11.097

Here is some kind of workaround. I admit that it looks totally ugly. But I think this is at least a way to get some kind of variadic style:

#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>

#include <boost/tuple/tuple.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/copy.hpp> 

#include <vector>

#define Foo(...) FooHelper< boost::mpl::vector<__VA_ARGS__> >

template<class T, class Tuple>
struct tuple_push_front;

template<class T, BOOST_PP_ENUM_PARAMS(10, class T)>
struct tuple_push_front<T, boost::tuple<BOOST_PP_ENUM_PARAMS(10, T)> > {
    typedef boost::tuple<T, BOOST_PP_ENUM_PARAMS(9, T)> type;
};

template <typename MPLVec>
struct FooHelper {
    typedef MPLVec mpl_vec_t;
    // generate a boost::tuple< std::vector<...>, ... > out of the mpl vector
    typedef typename boost::mpl::fold<mpl_vec_t,
        boost::tuple<>,
        tuple_push_front<std::vector<boost::mpl::_2>, boost::mpl::_1>
    >::type type;
};

int main() {
    Foo(int,float,char) test;
}

What it does is: There is a macro that supports the variadic arguments. This macro passes the args to an mpl::vector. The FooHelper is taking the mpl::vector<T1,...,Tn> and converts it to a boost::tuple< std::vector<T1>, ..., std::vector<Tn> >.

Well, I guess this is not what you want, but maybe you can use it somehow. I put it as answer and not as comment because of the large code block.

UPDATE: If you don't like the boost preprocessor stuff you can get the same result with a boost fusion vector. Quote from the boost doc: The tuple is more or less a synonym for fusion's vector..

#include <boost/fusion/container.hpp>
#include <boost/fusion/sequence.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/vector.hpp>

#include <vector>

#define Foo(...) FooHelper< boost::mpl::vector<__VA_ARGS__> >

template <typename T> 
struct make_vector { 
    typedef std::vector<T> type; 
}; 

template <typename MPLVec>
struct FooHelper {
    typedef MPLVec mpl_vec_t;
    typedef typename boost::mpl::transform<mpl_vec_t, make_vector<boost::mpl::_1> >::type vector_types;
    typedef typename boost::fusion::result_of::as_vector< vector_types >::type vectors_t;
    vectors_t _vectorsTuple;
};

int main() {
    Foo(int, double, float) x;
}

Thanks, that's not too bad :) Any chances the transform from the mpl::vector to the actual tuple could be less ugly ? Do we really need the BOOST_PP_ENUM macros and the custom push_front ? Wondering if that could be achieved in a smoother way using mpl::transform rather than fold — codeJack, Nov 18 '16 at 15:59
well, you could use `mpl::transform` on `mpl_vec_t` to transform the elements from `Tx` to `std::vector` and then just create a boost fusion vector out of it (`boost::fusion::result_of::as_vector::type`).. :) would definitely look less ugly. — Stefan Moosbrugger, Nov 18 '16 at 16:56
The output of the transform would still need to be a boost::tuple though, not a boost fusion vector. — codeJack, Nov 18 '16 at 17:04
I updated the code. It looks much simpler now (as expected). :) Just have a look at the code. To answer your question about the tuple please see the quote from the boost doc. — Stefan Moosbrugger, Nov 19 '16 at 10:01
For some particular constraints, I would still like to have a boost::tuple (even if they are similar wit a fusion::vector) would that be possible ? — codeJack, Nov 21 '16 at 10:50
Hmm... I don't have a solution without boost preprocessor on the quick. But I will think about it and maybe I'll find a solution. :) — Stefan Moosbrugger, Nov 21 '16 at 16:18
I used inheritance with a wrapper to avoid using the macro from your solution. Looks less disruptive from a client perspective. — codeJack, Nov 21 '16 at 17:34

c++03 : Variadic templates using boost

1 Answers1

Linked