c++ - 尝试交换可变参数模板类时如何正确重载 operator=？

Question

我有一个类(class)，我可以在其中选择任意数量的类(class)并将它们存储到 std::tuple 中.它是一个可变参数模板类。我已经正确地重载了 operator+运算符(operator)，他们按预期工作。但是，现在我正在尝试将一个 Controller 类分配给另一个 Controller 类。我尝试了以下方法:

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

但是，当我编译代码时，出现错误:“没有匹配函数来调用 std::tuple<A&,B&>::swap(std::tuple<A&,B&,A&>)

注意:参数 1 来自 std::tuple<A&,B&,A&> 的已知转换至 std::tuple<A&,B&>& "

简单地说，我正在尝试执行以下操作:

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;

这是我正在使用的代码:

#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

重载的正确方法是什么operator=在这种情况下？正如我所指出的，在我写这篇文章时，这可能是因为模板化类可能是一成不变的。所以Controller<ClassA,ClassB>不能修改为 Controller<ClassA,ClassB,ClassA>所以也许我需要退回一个新的 Controller ？

Answer 1

在 C++ 中，对象永远不能改变它们的类型，并且类模板的各种特化是不同的、不相关的类型。考虑一个假设的 std::vector<int*>::operator=(const std::vector<bool>&) ;很明显，这是一个无意义的请求，默认情况下，该限制会延续到 any 类模板，即使它没有类型依赖于模板参数的成员。 (这样做的一个次要原因是允许特化具有不相关的成员——通过继承或通过显式或部分特化。)

因此，定义一个接受包含类模板的任何特化的赋值运算符模板通常是没有意义的:人们无法对其数据做任何事情(对于此类模板的大多数特化) ).即使类模板是无状态的，通过这样的定义来削弱类型系统通常也不是一个好主意。

当然有一些方法可以绕过这些限制，但要在语法和效率方面付出各种代价。一个(小的)静态类型集合(尤其是相似大小的)可以保存在 std::variant<…> 中。 (内部是 union 或字节缓冲区)；一组无限的类型可以在std::any举行(除小对象外，它是指向内部堆分配的类型删除指针)。