Operator overloading in variadic template inheritance

Question

Imagine a code like this:

struct Foo
{
    int foo{0};
};

Foo operator+(const Foo& lhs, const Foo& rhs)
{
    Foo ret;
    ret.foo = lhs.foo + rhs.foo;
    return ret;
}

struct Bar
{
    int bar{0};
};

Bar operator+(const Bar& lhs, const Bar& rhs)
{
    Bar ret;
    ret.bar = lhs.bar + rhs.bar;
    return ret;
}

template<typename... Ts>
struct Fooz : public Ts...
{

};

template<typename... Ts>
Fooz<Ts...> operator+(const Fooz<Ts...>& lhs, const Fooz<Ts...>& rhs)
{
    // how can you call base class's operator+ here?
}

int main(int argc, char **argv)
{
    Fooz<Foo,Bar> fooz1{1,1}; // fooz1.foo == 1; fooz1.bar == 1;
    Fooz<Foo,Bar> fooz2{2,2}; // fooz2.foo == 2; fooz2.bar == 2;

    // auto fooz3 = fooz1 + fooz2 // fooz3.foo == 3; fooz3.bar == 3;
    return 0;
}

The variadic inheritance here is needed, since I want to have all the member variables from the base structs inherited to the variadic class (see main).

The question is: is it possible to call the base struct's operator+ inside FooBar's operator+ function?

Any help is appreciated!

Piotr Skotnicki · Accepted Answer · 2018-11-28 20:10:43Z

5

In c++17, if Fooz is an aggregate type as in the question, you can copy-list-initialize Fooz to (list)-initialize each direct base class with individual results:

template <typename... Ts>
Fooz<Ts...> operator+(const Fooz<Ts...>& lhs, const Fooz<Ts...>& rhs)
{    
    return { {static_cast<const Ts&>(lhs) + static_cast<const Ts&>(rhs)}... };
}

DEMO

In c++14, you'd additionally need to provide a constructor:

Fooz(const Ts&... ts) : Ts{ts}... {}

edited Nov 28, 2018 at 20:10

answered Nov 28, 2018 at 19:41

Piotr Skotnicki

48.8k7 gold badges122 silver badges167 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

lubgr Over a year ago

This is awesome! Is there a similar solution if Fooz is not an aggregate type, too?

Piotr Skotnicki Over a year ago

@lubgr you would need a user-provided constructor that explicitly calls the constructors of base classes on a member initalizer list

user4442671 Over a year ago

@lubgr, if you work with operator+= instead, you could use a comma fold-expression: gcc.godbolt.org/z/wt8OlR, this way, no need for the aggregate initialization. (C++17 only)

serkan.tuerker Over a year ago

@Frank That's great with the operator+= and comma fold-expression.

user4442671 · Accepted Answer · 2018-11-28 20:44:20Z

2

Since the question is tagged C++11, as an alternative to @PiotrSkotnicki, it's worth mentioning that good-old recursive peeling of the variadic parameters can also be used to achieve that:

template<typename T, typename... Rest>
struct Aggregate_add_impl {
  static void add(T& dst, const T& lhs, const T& rhs) {
    // intentional no-op
  }  
};

template<typename T, typename U, typename... Rest>
struct Aggregate_add_impl<T, U, Rest...> {
  static void add(T& dst, const T& lhs, const T& rhs) {
      U& dst_as_u = static_cast<U&>(dst);
      const U& l_as_u = static_cast<const U&>(lhs);
      const U& r_as_u = static_cast<const U&>(rhs);

      dst_as_u = l_as_u + r_as_u;
      Add_impl<T,Rest...>::add(dst, lhs, rhs);
  }
};

template <typename... Ts>
Fooz<Ts...> operator+(const Fooz<Ts...>& lhs, const Fooz<Ts...>& rhs)
{    
    Fooz<Ts...> ret;
    Aggregate_add_impl<Fooz<Ts...>, Ts...>::add(ret, lhs, rhs);
    return ret;
}

This also has the benefit of not requiring Fooz to be aggregate constructible (but it DOES have to be default or copy-constructible).

It's worth noting that implementing operator+= this way is actually quite a bit simpler, so if you have both + and +=, just implement the later instead.

answered Nov 28, 2018 at 20:44

user4442671

1 Comment

serkan.tuerker Over a year ago

Thank you @Frank. This is also super useful for people with older compilers!

Collectives™ on Stack Overflow

Operator overloading in variadic template inheritance

2 Answers 2

4 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related