容器中的对象拷贝

《Effective STL》第3条

当往容器中保存对象时，保存的并不是提供给容器的那些对象，而是那些对象的拷贝。

如何拷贝？利用的是对象的拷贝构造函数。

#include <iostream>
#include <vector>
using namespace std;

class Foo
{
public:
    Foo(int x):_x(x)
    {
        cout << "constructor" << endl;
    }
    ~Foo()
    {
        cout << "destructor" << endl;
    }

private:
    int _x;
};

int main()
{
    vector<Foo> vec;
    Foo f(1);
    vec.push_back(f);
    return 0;
}

成功执行，输出

constructor
destructor
destructor

编译会帮忙生成拷贝构造函数

如果禁用拷贝构造函数

#include <iostream>
#include <vector>
using namespace std;

class Foo
{
public:
    Foo(int x):_x(x)
    {
        cout << "constructor" << endl;
    }
    ~Foo()
    {
        cout << "destructor" << endl;
    }

    Foo (const Foo&) = delete;
private:
    int _x;
};

int main()
{
    vector<Foo> vec;
    Foo f(1);
    vec.push_back(f);
    return 0;
}

编译时会报错

/usr/include/c++/4.7/bits/stl_construct.h:77:7: error: use of deleted function ?.oo::Foo(const Foo&)?

 如果自己定义了拷贝构造函数

#include <iostream>
#include <vector>
using namespace std;

class Foo
{
public:
    Foo(int x):_x(x)
    {
        cout << "constructor" << endl;
    }
    ~Foo()
    {
        cout << "destructor" << endl;
    }

    Foo (const Foo& f)
    {
        cout << "copy constructor" << endl;
        _x = f._x;
    }
private:
    int _x;
};

int main()
{
    vector<Foo> vec;
    Foo f(1);
    vec.push_back(f);
    return 0;
}

执行输出：

constructor
copy constructor
destructor
destructor

执行了自己定义的拷贝构造函数

对于内置类型来说，总是简单的按位拷贝。

结论：由于容器会创建拷贝，所以如果一个对象的拷贝很费时，那就有可能成为性能瓶颈。

如何提高性能？

避免拷贝

使用指针

#include <iostream>
#include <vector>
using namespace std;

class Foo
{
public:
    Foo(int x):_x(x)
    {
        cout << "constructor" << endl;
    }
    ~Foo()
    {
        cout << "destructor" << endl;
    }

    Foo (const Foo& f)
    {
        cout << "copy constructor" << endl;
        _x = f._x;
    }
private:
    int _x;
};

int main()
{
    vector<Foo*> vec;
    Foo* f = new Foo(1);
    vec.push_back(f);
    return 0;
}

输出

constructor

这里有个问题，new 的指针没有释放，容器对象在析构时，不能自动释放成员指针指向的内存。

 必须自己释放

int main()
{
    vector<Foo*> vec;
    Foo* f = new Foo(1);
    vec.push_back(f);
    delete f;
    return 0;
}

有点麻烦，现在可以考虑使用智能指针了

#include <iostream>
#include <memory>
#include <vector>
using namespace std;

class Foo
{
public:
    Foo(int x):_x(x)
    {
        cout << "constructor" << endl;
    }
    ~Foo()
    {
        cout << "destructor" << endl;
    }

    Foo (const Foo& f)
    {
        cout << "copy constructor" << endl;
        _x = f._x;
    }
private:
    int _x;
};

int main()
{
    vector<shared_ptr<Foo>> vec;
    shared_ptr<Foo> f = make_shared<Foo>(1);
    vec.push_back(f);
    return 0;
}

执行输出

constructor
destructor

只构造了一次对象，并且可以正常释放了。