9

在 C++ 中，当类包含动态分配的数据时，显式定义复制构造函数、operator= 和析构函数通常是合理的。但是这些特殊方法的活动是重叠的。更具体地说， operator= 通常首先进行一些破坏，然后进行类似于复制构造函数中的处理。

我的问题是如何在不重复相同代码行且不需要处理器做不必要的工作（如不必要的复制）的情况下以最佳方式编写此代码。

我通常会得到两种帮助方法。一种用于建设，一种用于破坏。第一个是从复制构造函数和 operator= 调用的。第二个由析构函数和 operator= 使用。

这是示例代码：

    template <class T>
    class MyClass
    {
        private:
        // Data members
        int count;
        T* data; // Some of them are dynamicly allocated
        void construct(const MyClass& myClass)
        {
            // Code which does deep copy
            this->count = myClass.count;
            data = new T[count];
            try
            {
                for (int i = 0; i < count; i++)
                    data[i] = myClass.data[i];
            }
            catch (...)
            {
                delete[] data;
                throw;
            }
        }
        void destruct()
        {
            // Dealocate all dynamicly allocated data members
            delete[] data;
        }
        public: MyClass(int count) : count(count)
        {
            data = new T[count];
        }
        MyClass(const MyClass& myClass)
        {
            construct(myClass);
        }
        MyClass& operator = (const MyClass& myClass)
        {
            if (this != &myClass)
            {
                destruct();
                construct(myClass);
            }
            return *this;
        }
        ~MyClass()
        {
            destruct();
        }
    };

这甚至正确吗？以这种方式拆分代码是一个好习惯吗？

4

3 回答 3

8

一个初步的评论：operator=不是从破坏开始，而是从构造开始。否则，如果构造通过异常终止，它将使对象处于无效状态。因此，您的代码不正确。（请注意，测试自赋值的必要性通常表明赋值运算符不正确。）

处理此问题的经典解决方案是 swap 习惯用法：添加成员函数 swap：

void MyClass:swap( MyClass& other )
{
    std::swap( count, other.count );
    std::swap( data, other.data );
}

保证不会扔。（这里，它只是交换一个 int 和一个指针，两者都不能抛出。）然后你将赋值运算符实现为：

MyClass& MyClass<T>::operator=( MyClass const& other )
{
    MyClass tmp( other );
    swap( tmp );
    return *this;
}

这是简单而直接的，但是在您开始更改数据之前完成所有可能失败的操作的任何解决方案都是可以接受的。对于像您的代码这样的简单案例，例如：

MyClass& MyClass<T>::operator=( MyClass const& other )
{
    T* newData = cloneData( other.data, other.count );
    delete data;
    count = other.count;
    data = newData;
    return *this;
}

（ wherecloneData是一个成员函数，它执行您所做的大部分工作construct，但返回指针，并且不修改 中的任何内容this）。

编辑：

与您最初的问题没有直接关系，但通常，在这种情况下，您不想执行new T[count]in cloneData（或construct，或其他）。这T使用默认构造函数构造所有的，然后分配它们。这样做的惯用方式是这样的：

T*
MyClass<T>::cloneData( T const* other, int count )
{
    //  ATTENTION! the type is a lie, at least for the moment!
    T* results = static_cast<T*>( operator new( count * sizeof(T) ) );
    int i = 0;
    try {
        while ( i != count ) {
            new (results + i) T( other[i] );
            ++ i;
        }
    } catch (...) {
        while ( i != 0 ) {
            -- i;
            results[i].~T();
        }
        throw;
    }
    return results;
}

大多数情况下，这将使用单独的（私有）管理器类来完成：

//  Inside MyClass, private:
struct Data
{
    T* data;
    int count;
    Data( int count )
        : data( static_cast<T*>( operator new( count * sizeof(T) ) )
        , count( 0 )
    {
    }
    ~Data()
    {
        while ( count != 0 ) {
            -- count;
            (data + count)->~T();
        }
    }
    void swap( Data& other )
    {
        std::swap( data, other.data );
        std::swap( count, other.count );
    }
};
Data data;

//  Copy constructor
MyClass( MyClass const& other )
    : data( other.data.count )
{
    while ( data.count != other.data.count ) {
        new (data.data + data.count) T( other.date[data.count] );
        ++ data.count;
    }
}

（当然还有赋值的交换习语）。这允许多个计数/数据对，而不会失去异常安全性。

于 2013-07-10T10:09:25.130 回答
0

只要您确保不声明构造或破坏虚拟，我看不出有任何内在问题。

您可能会对 Effective C++ (Scott Meyers) 中的第 2 章感兴趣，该章完全致力于构造函数、复制运算符和析构函数。

至于您的代码未按应有的方式处理的异常，请考虑更有效的 C++ (Scott Meyers) 中的第 10 条和第 11 条。

于 2013-07-10T10:07:21.683 回答
0

通过首先复制右侧然后与之交换来实现分配。通过这种方式，您还可以获得异常安全，这是您上面的代码未提供的。否则，当 destruct() 成功后，construct() 失败时，您最终可能会导致容器损坏，因为成员指针引用了一些已释放的数据，并且在销毁时将再次释放，从而导致未定义的行为。

foo&
foo::operator=(foo const& rhs)
{
   using std::swap;
   foo tmp(rhs);
   swap(*this, tmp);
   return *this;
}
于 2013-07-10T10:03:49.260 回答