How to forward all unknown parameters in constructor to initialize the member object?

Question

I am trying to do something like this:

struct Foo {
    int _val;
    Foo(int v) : _val(v){} 
};

struct Bar {
    const std::string &_name;
    Bar(const std::string &name) : _name(name) {} 
};

template<typename T>
struct Universal {
    T _t;
    Universal(...) : _t(...) {} 
};

// I want to use Universal for Foo abd Bar in the same way:
Universal<Foo> UF(9);       // 9 is for Foo
Universal<Bar> UB("hello"); // "hello" is for bar

In the code above, I would like to forward all parameters in Universal's constructor to T's constructor.

How could I do it?

score 4 · Answer 1 · edited May 23 '17 at 10:27

4

You need to make Universal constructor be a variadic template, and use a parameter pack and perfect forwarding.

template<typename T>
struct Universal {
    T _t;

    template <typename... Args>
    Universal(Args&&... args) : _t(std::forward<Args>(args)...) {} 
};

Unfortunately as AndyG notes in the comments, this means that if you try and copy a non-const Universal object, the forwarding version gets preferred - so you need explicit const and non-const copy constructors!

template<typename T>
struct Universal {
    T _t;

    template <typename... Args>
    Universal(Args&&... args) : _t(std::forward<Args>(args)...) {} 

    Universal(const Universal& rhs): _t(rhs._t) {}
    Universal(      Universal& rhs): _r(rhs._t) {}

    // ... but not move constructors.
};

or use the SFINAE approach shown in this answer, to make sure the default constructor is preferred.

edited May 23 '17 at 10:27

Community

1
1

answered Oct 11 '16 at 12:57

Martin Bonner supports Monica

28,528
3
51
88

1

Yep, but one gotcha here is that this constructor will be preferred over the copy and move constructors most of the time. Extra work would need to be done if you intend otherwise. – AndyG Oct 11 '16 at 13:02
@AndyG are you sure about that? Won't a variadic template ctor be a less match than a cpy ctor? – bolov Oct 11 '16 at 13:03
@bolov: The problem is that most of the time when people want the copy ctor called, the argument they pass in isn't already const, so the forwarding reference is a better match. – AndyG Oct 11 '16 at 13:05
@AndyG Jesus, the ways C++ can bite you in the a**. – bolov Oct 11 '16 at 13:08
Are you sure: I thought a template was *never* a copy constructor. – Martin Bonner supports Monica Oct 11 '16 at 13:08
1

[Here's an example of what I mean](http://coliru.stacked-crooked.com/a/c5942bf263ec506b) – AndyG Oct 11 '16 at 13:08
I should also add that I was wrong about the move ctor, this is really only a problem for the copy ctor. – AndyG Oct 11 '16 at 13:11
@AndyG That is because it is an exact match in that case which is preferred over the template always. – NathanOliver Oct 11 '16 at 13:14
OK. You're sure. Eeeew! – Martin Bonner supports Monica Oct 11 '16 at 13:14
@MartinBonner This is why SFINAE should be applied to template constructors. Here is a useful Q&A: http://stackoverflow.com/questions/39645986/constructor-using-stdforward – NathanOliver Oct 11 '16 at 13:18

score 0 · Answer 2 · edited May 23 '17 at 10:27

0

Simple:

template<typename T>
struct Universal {
    T _t;
    Universal(const T& val) : _t(val) {} 
};

iff performance is of concern or if you want to support move only types you can forward the parameter:

template<typename T>
struct Universal {
    T _t;
    template <class U>
    Universal(U&& val) : _t(std::forward<U>(val)) {} 
};

Please note we need a template parameter U for the ctor in order for the forwarding to work. T&& would be just a rvalue reference.

If you want to get more fancy, you can construct in place:

template<typename T>
struct Universal {
    T _t;
    template <class... Args>
    Universal(Args&&... args) : _t(std::forward<Args>(args)...) {} 
};

As AndyG suggested in a comment, extra work would need to be done if you want cpy and mv ctors to work as expected.

The rule is: keep it simple unless there is a good reason justifying the complications. I think that the first variant is more than enough for you.

edited May 23 '17 at 10:27

Community

1
1

answered Oct 11 '16 at 12:54

bolov

72,283
15
145
224

If Foo or Bar have an explicit constructor, or don't have a copy constructor, then you will have to forward the parameter, whether or not you care about performance. – Martin Bonner supports Monica Oct 11 '16 at 12:59
the explicit ctor is not a problem. You are right about move-only types. Ty, good catch – bolov Oct 11 '16 at 13:01
I think the explicit ctor is a problem: `struct Foo{ explicit Foo(int i) {} }; void f(const Foo& f) {}; f(1);` will fail because you are trying to implicitly create a Foo. That is what you are suggesting in your first suggestion. – Martin Bonner supports Monica Oct 11 '16 at 13:04
@MartinBonner if the constructor is explicit, then the expected way would be `f(Foo{1})`. That's why it's explicit. – bolov Oct 11 '16 at 13:09
similar, I would want `universal` to work like this: `f(universal){}; f(Foo{1})`, which it does. – bolov Oct 11 '16 at 13:10

How to forward all unknown parameters in constructor to initialize the member object?

2 Answers2