假设我有赋值运算符，我的复制构造函数是 this = obj 好吗？

Question

基本上，我的问题如下：假设我为一个类创建了一个赋值运算符，是否违反约定或不赞成让我的复制构造函数只是 this = item？

假设我正在创建一个仅包含以下数据的模板类：

private:
    int       _size;
    ItemType* _array;

如果我的赋值运算符如下：

template<class ItemType>
void obj<ItemType>::operator = (const obj & copyThis){
    _size = copyThis.getSize(); 
    _array = new ItemType[_size];
    for (int i = 0; i < _size; i++){
        //assuming getItemAt is a function that returns whatever is in given location of object's _array
        _array[i] = copyThis.getItemAt(i);
    }
}

如果我的复制构造函数简单如下，会不会违反约定/被看不起/被认为不正确？

template<class ItemType>
obj<ItemType>::obj(const obj & copyThis){
    this = copyThis;
}

Answer 1

在复制构造函数中调用operator= 通常是安全的（只要operator= 不尝试将复制构造函数用作其逻辑的一部分）。

但是，您的 operator= 一开始就实施错误。它会泄漏内存，不处理分配给自身的this，并且不返回对this 的引用。

试试这个：

template<class ItemType>
obj<ItemType>::obj(const obj & copyThis)
    : _size(0), _array(0)
{
    *this = copyThis;
}

template<class ItemType>
obj<ItemType>& obj<ItemType>::operator=(const obj<ItemType> &copyThis)
{
    if (this != &copyThis)
    {
        int newSize = copyThis.getSize(); 
        ItemType *newArray = new ItemType[newSize];

        // consider using std::copy() instead:
        //
        // std::copy(copyThis._array, copyThis._array + newSize, newArray);
        //
        for (int i = 0; i < newSize; ++i) {
            newArray[i] = copyThis.getItemAt(i);
        }

        delete[] _array;
        _array = newArray;
        _size = newSize; 
    }

    return *this;
}

话虽如此，通常最好使用复制构造函数实现operator=，而不是相反：

template<class ItemType>
obj<ItemType>::obj(const obj & copyThis)
    : _size(copyThis.getSize()), _array(new ItemType[_size])
{
    for (int i = 0; i < _size; ++i){
        _array[i] = copyThis.getItemAt(i);
    }

    // or:
    // std::copy(copyThis._array, copyThis._array + _size, _array);
}

template<class ItemType>
obj<ItemType>& obj<ItemType>::operator=(const obj<ItemType> &copyThis)
{
    if (this != &copyThis)
    {
        obj<ItemType> tmp(copyThis); 
        std::swap(_array, tmp._array);
        std::swap(_size, tmp._size);
    }

    return *this;
}

如果添加swap方法可以稍微清理一下：

template<class ItemType>
obj<ItemType>::obj(const obj & copyThis)
    : _size(copyThis.getSize()), _array(new ItemType[_size])
{
    for (int i = 0; i < _size; ++i){
        _array[i] = copyThis.getItemAt(i);
    }
}

template<class ItemType>
void obj<ItemType>::swap(obj<ItemType> &swapThis)
{
    std::swap(_array, swapThis._array);
    std::swap(_size, swapThis._size);
}

template<class ItemType>
obj<ItemType>& obj<ItemType>::operator=(const obj<ItemType> &copyThis)
{
    if (this != &copyThis) {
        obj<ItemType>(copyThis).swap(*this); 
    }

    return *this;
}

话虽如此，如果您将手动数组替换为std::vector，那么您根本不需要手动实现复制构造函数或复制赋值运算符，编译器生成的默认值就足够了（因为@ 987654333@ 已经实现了复制语义）。