-1

让我们看一下以下三个类：

class IntTab0 {
    private:
        int length;
        int* data;

    public:
        IntTab0(): length(0), data(nullptr) {}

        IntTab0(int size): length(size) {
            assert(size > 0);
            data = new int[length];
        }

        IntTab0(const IntTab0& rhs): length(0), data(nullptr) {
            if (rhs.data) {
                length = rhs.length;
                data = new int(*rhs.data);
            }
        }

        ~IntTab0() {
            delete[] data;
        }

        void swap(IntTab0& second) {
            using std::swap;
            swap(length, second.length);
            swap(data, second.data);
        }
};

class IntTab1 : public IntTab0 {
    public:
        IntTab1(): IntTab0() {}
        IntTab1(int size): IntTab0(size) {}
        IntTab1(const IntTab1& rhs): IntTab0(rhs) {}

        IntTab1(IntTab1&& rhs) noexcept {
            swap(rhs);
        }

        IntTab1& operator=(IntTab1&& rhs) noexcept {
            swap(rhs);
            return *this;
        }
};

class IntTab2 : public IntTab0 {
    public:
        IntTab2(): IntTab0() {}
        IntTab2(int size) : IntTab0(size) {}
        IntTab2(const IntTab2& rhs): IntTab0(rhs) {}

        IntTab2(IntTab2&& rhs) {
            swap(rhs);
        }

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

我还有一个功能来衡量他们每个人的表现：

template<class Value>
void test_Performance() {
    std::vector <Value> vit;

    std::chrono::time_point<std::chrono::system_clock> start, end;
    start = std::chrono::system_clock::now();

    for (int i = 0; i < 100000; i++) {
        Value it(5);
        vit.push_back(it);
    }
    std::vector <Value> vitCopy(std::move(vit));

    end = std::chrono::system_clock::now();

    std::chrono::duration<double> elapsed_seconds = end-start;
    std::cout << "elapsed time for IntTab" << it++ << ": " << elapsed_seconds.count() << "s\n";
}

我不太明白的是为我的类的每个实例运行此性能测试的结果。我怀疑 IntTab1 应该是最快的，因为它使用移动构造函数和移动赋值运算符，没有例外。事实上，在我的环境中结果是相反的——最快的是 C++98 版本，只使用了复制构造函数和赋值运算符。这是我的结果：

IntTab 的经过时间：2.2873e-05s

IntTab1 的经过时间：2.4139e-05s

IntTab2 的经过时间：2.3554e-05s

有人可以解释这种奇怪的行为吗？

编辑

根据关于错误复制构造函数（不做真正的深拷贝）的评论 - 我有一个测试功能，我假设它测试这种行为：

void test_IntTab( void ) {
    IntTab0 it( 5 );
    it[0] = 10;
    it[4] = 20;
    assert( it.size() == 5 );
    assert( it[0] == 10 );
    assert( it[4] == 20 );

    IntTab0 iu( 10 );
    iu[0] = 17;
    iu[4] = 34;
    assert( iu.size() == 10 );
    assert( iu[0] == 17 );
    assert( iu[4] == 34 );

    iu.swap( it );
    assert( iu.size() == 5 );
    assert( iu[0] == 10 );
    assert( it.size() == 10 );
    assert( it[0] == 17 );

    IntTab0 is( iu );
    assert( is.size() == 5 );
    assert( is[0] == 10 );

    IntTab0 iw;
    iw = it;
    assert( iw.size() == 10 );
    assert( iw[0] == 17 );

    it[0] = 1;
    iu[0] = 2;
    is[0] = 3;
    iw[0] = 4;

    assert( it[0] == 1 );
    assert( iu[0] == 2 );
    assert( is[0] == 3 );
    assert( iw[0] == 4 );
}

如果我的复制构造函数不能正常工作，为什么这个函数能正常运行？

4

1 回答 1

3

您的复制构造函数没有正确复制整个数据。

您不复制复制构造函数中的内容，它只是分配内存。所以，它不是完整的复制构造函数。这个不完整的方法应该比移动构造函数更快。

    IntTab0(const IntTab0& rhs): length(0), data(nullptr) {
        if (rhs.data) {
            length = rhs.length;
            data = new int(*rhs.data);

            ///////////////////////////////////////////
            // Assuming data is an array             //
            // std::copy from rhs.data to this->data //
            ///////////////////////////////////////////
        }
    }

如果您的复制构造函数不必深度复制成员，那么移动它并没有太多优势而不是复制。

于 2013-11-05T07:56:39.490 回答