C++: эффективно копировать контейнеры

Question

Как скопировать контейнеры STL?

// big containers of POD 
container_type<pod_type> source; 
container_type<pod_type> destination 

// case 1 
destination = source; 

// case 2 
destination.assign(source.begin(), source.end()); 

// case 3 assumes that destination.size() >= source.size() 
copy(source.begin(), source.end(), destination.size()); 

Я использую случай 1, когда это возможно. Случай 2 предназначен для контейнеров разных типов. Случай 3 необходим, когда место назначения больше, чем источник, и вы хотите сохранить остальные элементы.

Но как насчет не-POD-элементов с ненулевой стоимостью строительства/разрушения? Может ли случай 3 быть лучше, чем случай 2? Если назначение больше, чем источник, реализация может сделать довольно неожиданные вещи. Это то, что Visual Studio 2008 делает в случае 2.

1. Все элементы места назначения уничтожены.
2. Затем конструктор копирования вызывается столько раз, сколько размер адресата. Зачем?
3. Все элементы источника назначаются соответствующим элементам назначения.
4. Дополнительные элементы места назначения уничтожены.

GCC 4.5 лучше. Все элементы источника копируются через назначение, а затем удаляются дополнительные элементы адресата. Используя случай 3, за которым следует , размер делает то же самое на обеих платформах (кроме одного конструктора по умолчанию, который имеет размер). Вот игрушечная программа, которая показывает, что я имею в виду.

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

struct A { 
    A() { cout << "A()\n"; } 
    A(const A&) { cout << "A(const A&)\n"; } 
    A& operator=(const A&) { 
     cout << "operator=\n"; 
     return *this; 
    } 
    ~A() { cout << "~A()\n"; } 
}; 

int main() { 
    list<A> source(2); 
    vector<A> desrination1(3); 
    vector<A> desrination2(3); 

    cout << "Use assign method\n"; 
    desrination1.assign(source.begin(), source.end()); 

    cout << "Use copy algorithm\n"; 
    copy(source.begin(), source.end(), desrination2.begin()); 
    desrination2.resize(2); 

    cout << "The End" << endl; 
    return 0; 
} 

Answer 1

Все элементы пункта назначения - уничтожены. Затем конструктор копирования вызывается столько раз, сколько размер адресата . Зачем?

Не уверен, что вы говорите. назначьте обычно реализуется как-то:

template<class Iterator> 
void assign(Iterator first, Iterator last) 
{ 
     erase(begin(), end()); // Calls the destructor for each item 
     insert(begin(), first, last); // Will not call destructor since it should use placemenet new 
} 

с копирования вы могли бы сделать что-то вроде:

assert(source.size() <= destination.size()); 
destination.erase(copy(source.begin(), source.end(), destination.begin()), destination.end()); 

, которые должны быть в значительной степени то же самое. Я бы использовал копию, если бы я точно знал, что источник поместится в пункт назначения (немного быстрее, так как для назначения/вставки нужно проверить емкость контейнера), иначе я бы использовал назначение, поскольку он прост. Также, если вы используете копию и место назначения слишком мало, вызов resize() неэффективен, так как resize() будет создавать все элементы, которые будут перезаписаны в любом случае.

GCC 4.5 лучше.Все элементы источника копируются через , а затем удаляются дополнительные элементы места назначения. Использование case 3 с последующим изменением размера делает то же самое на обеих платформах (за исключением одного конструктора по умолчанию, который требует ). Вот игрушечная программа , которая показывает, что я имею в виду.

Это то же самое. Назначение выполняется с точки зрения построения копии.

class A 
{ 
    A& operator=(A other) 
    { 
     std::swap(*this, other); 
     return *this; 
    } 

    // Same thing but a bit more clear 
    A& operator=(const A& other) 
    { 
     A temp(other); // copy assignment 
     std::swap(*this, temp); 
     return *this; 
    } 
} 

Answer 2

Если вы копируете весь контейнер, вам следует полагаться на конструктор или экземпляр контейнера. Но если вы копируете только содержимое контейнера от одного к другому, лучше всего использовать std::copy. Вы не можете сохранить вызов конструктора копирования для каждого экземпляра, если используете более чем объект POD.

Вам следует подумать об использовании общих/интеллектуальных указателей, которые будут только увеличивать свои счетчики ссылок при копировании и использовать копирование при записи при изменении вашего экземпляра.