How to properly overload operator= when trying to swap variadic templated classes?

Question

I have a class in which I take any number of classes and store them into a std::tuple. It is a variadic templated class. I have properly overloaded the operator+ operator and they work as intended. However, now I am trying to assign one controller class to another. I have tried the following:

template<typename...ClassesR>
auto operator=(const Controller<ClassesR...>& rhs)
{
  objects.swap(rhs.getObjects());
  return *this;
}

However, when I compile the code, I get the error: "No matching function for call to std::tuple<A&,B&>::swap(std::tuple<A&,B&,A&>)

note: no known conversion for argument 1 from std::tuple<A&,B&,A&> to std::tuple<A&,B&>&"

Simply put, I am trying to do the following:

ClassA A(3);
ClassB B(3.4);
ClassC C(4.5f);

Controller<ClassA,ClassB> controllerA(A,B);
Controller<ClassC> controllerB(C);

// thinking about it now, this might be the problem...because controllerA is actually
// Controller<ClassA,ClassB> and not Controller<ClassA,ClassB,ClassA>.
controllerA = controllerA + controllerB; 

//or
//controllerA = controllerB;

Here is the code that I am working with:

#ifndef CONTROLLER_HPP
#define CONTROLLER_HPP

#include <functional>
#include <vector>
#include <utility>
#include <any>

template<typename...Classes>
class Controller
{
  public:
    Controller(Classes&...objects) : objects(objects...){ }
    Controller(std::tuple<Classes&...> tup) : objects(tup){ }

    //...a bunch of code that doesn't matter

    std::tuple<Classes&...> getObjects() const
    {
      return objects;
    }        

    template<typename...ClassesR>
    auto operator=(const Controller<ClassesR...>& rhs)
    {

      objects.swap(rhs.getObjects());

      return *this;
    }

  private:
    std::tuple<Classes&...> objects;

};

template<typename...ClassesL, typename...ClassesR>
auto operator+(const Controller<ClassesL...>& lhs, const Controller<ClassesR...>& rhs)
{
  return Controller(std::tuple_cat(lhs.getObjects(),rhs.getObjects()));
}

template<typename...ClassesL, typename ClassesR>
auto operator+(const Controller<ClassesL...> &lhs, ClassesR rhs)
{
  Controller<ClassesR> makeController(rhs);
  return Controller(std::tuple_cat(lhs.getObjects(),makeController.getObjects()));
}

template<typename ClassesL, typename...ClassesR>
auto operator+(ClassesL lhs, const Controller<ClassesR...> &rhs)
{
  Controller<ClassesL> makeController(lhs);
  return Controller(std::tuple_cat(makeController.getObjects(),rhs.getObjects()));
}


#endif // CONTROLLER_HPP

What is the proper way to overload operator= in this case? As I noted, as I am writing this it is possible that it is because the templated classes are probably set in stone. So Controller<ClassA,ClassB> cannot be modified to Controller<ClassA,ClassB,ClassA> so maybe I need to return a new controller?

1) I smell a constness problem 2) Shouldn't it be `auto&`, not `auto`? — , Nov 14 '19 at 00:44
I tried auto& and got the same exact error. Why do you smell a constness problem? — Sailanarmo, Nov 14 '19 at 00:49
Because weird problems like this are often because you are passing by `const &`, which you are in this case. See my answer. — , Nov 14 '19 at 00:56
You’re right about what “might be the problem”: your `operator+` returns a different type. That’s legitimate, but it doesn’t allow assignment back to the original. In short, your `operator=` doesn’t need to be a template here (at least not for this reason). — Davis Herring, Nov 14 '19 at 03:09
@Sailanarmo: That’s what assignment operators usually do, yes. — Davis Herring, Nov 14 '19 at 03:20
@DavisHerring, upon doing that I still get the error "no known conversion for arguiment 1 from Controller to Controller ". I changed the line to be `auto& operator=(Controller rhs){ std::swap(*this,rhs); return *this; }` — Sailanarmo, Nov 14 '19 at 03:39
@Sailanarmo: I didn’t say that the normal assignment operator would let you do what you’re trying; I said that goal was impossible (absent type-erasing wrappers) and thus there was no point in attempting it via a complicated assignment operator. — Davis Herring, Nov 14 '19 at 03:50
@DavisHerring, I'm sorry, now that I have a clear head, yes you are right that is exactly what you said. Basically since one controller is already set in it's template there is no way to change it by assignment. Would you mind writing this as an answer and then I can accept it so you can get credit? — Sailanarmo, Nov 14 '19 at 03:53
`Controller` doesn't make sense because `A` and `B` are not types. — aschepler, Nov 14 '19 at 05:56
@aschepler. I am not sure what you mean. I stated that this class takes a bunch of classes in my post. I left out a bunch of code that handles calls to those classes. I do agree that `typename` is misleading. I should perhaps change it to `class` instead. If that is what you are talking about? — Sailanarmo, Nov 14 '19 at 15:47
In `ClassA A(3);`, `ClassA` is apparently a type, but `A` is an object of that type. So you probably meant to say `Controller`. It just made the question harder to understand is all. But I think the answer by Davis got the core of it well enough, so it's moot now. — aschepler, Nov 14 '19 at 22:25
@aschepler oh shoot! You are correct! I will go ahead and make that correction. — Sailanarmo, Nov 14 '19 at 22:31

score 2 · Accepted Answer · answered Nov 14 '19 at 05:29

In C++, objects cannot ever change their type, and the various specializations of a class template are different, unrelated types. Consider a hypothetical std::vector<int*>::operator=(const std::vector<bool>&); it’s obvious that this is a meaningless request, and by default that restriction carries over to any class template, even if it has no members whose types depend on the template parameters. (One minor reason for this is that specializations are allowed to have unrelated members—either by inheritance or by explicit or partial specializations.)

As such, it’s generally meaningless to define an assignment operator template that accepts any specialization of the containing class template: there’s simply nothing that one can do with its data (for most specializations of such a template). Even if the class template is stateless, it’s not usually a good idea to weaken the type system by such a definition.

There are of course ways around these restrictions at various costs in terms of syntax and efficiency. A (small) static collection of types (especially of similar size) can be held in a std::variant<…> (which is a union or byte buffer internally); an unbounded set of types can be held in a std::any (which, except for small objects, is a type-erased pointer to a heap allocation internally).

score 1 · Answer 2 · answered Nov 14 '19 at 00:55

As seen in this question: What are the basic rules and idioms for operator overloading?, the proper way to do this is accept an object by value, not by const reference. So, for example:

auto& operator=(Controller<ClassesR...> rhs)

Part of the reason for this (I'm assuming), as you are finding out, is that if you pass by const &, you are forced to only use const functions. swap() is not a constant function.

Also, auto is never a reference unless you make it one. Thus, to follow the opertor= idiom, you need to return a auto&.

More information on this that explains it far better than I could.

I implemented this and I have the same exact error. Word for word. Also, I am using `tuple::swap` on this one, not `std::swap`. I have tried `std::swap(objects,rhs.getObjects())` and `std::swap(*this,rhs)` both do not compile with the same no matching function call to swap. — Sailanarmo, Nov 14 '19 at 01:42

How to properly overload operator= when trying to swap variadic templated classes?

2 Answers2