Question

我有一个类似

的课程

class A{
    double a, b, c, d, e;
    float af, bf, cf, df, ef;
    std::vector<double> av, bv, cv, dv, ev;
    std::vector<std::vector<double>> avv, bvv, cvv, dvv, evv;

    A(){}
    A(/*init values*/){/*Initialize all the values above using the input values*/}
    ~A(){}
}

现在我想实现一个赋值运算符，这样我就可以（在第二个类中）：

class B{
    private:
        A ac, bc, dc;
    public:
        B(/*init values*/)
        {
            ac = A(/*init values*/);
            bc = A(/*init values*/);
            dc = A(/*init values*/);
        }
        ~B(){}
}

我知道我可以关注What is the copy-and-swap idiom?和What are the basic rules and idioms for operator overloading?并实施

A& A::operator=(A rhs)
{
  swap(rhs);
  return *this;
}

和相应的swap - 函数：

friend void swap(A& first, A& second)
{
    using std::swap;

    swap(/*for each element*/);
}

对所有元素执行此操作很容易忘记一个元素，从而导致代码出错。未来的扩展也是如此，即在类头中添加变量，但不在交换函数中添加。有没有更简单的方法呢？

Answer 1

您可以将所有数据成员放在聚合中，并且不要声明任何构造函数，赋值运算符和析构函数。您将获得默认移动/复制构造函数/赋值和聚合初始化的好处（如果初始化是直接的，这可能会有所帮助）：

struct A{
    double a, b, c, d, e;
    float af, bf, cf, df, ef;
    std::vector<double> av, bv, cv, dv, ev;
    std::vector<std::vector<double>> avv, bvv, cvv, dvv, evv;
    };
void swap(A& a,A& b){
    a=std::exchange(b,a);
    }

如果你必须维护一些不变量，在内部结构中声明数据可能会有所帮助：

class A{
  struct data_t{
    double a, b, c, d, e;
    float af, bf, cf, df, ef;
    std::vector<double> av, bv, cv, dv, ev;
    std::vector<std::vector<double>> avv, bvv, cvv, dvv, evv;
    };
  data_t data;
  //[...]
  void swap(A& other){
     data = std::exchange(other.data,data);
     }
  };

为具有大量元素的类实现赋值运算符

1 个答案: