Вступление

C ++ обрабатывает переменные определяемых пользователем типов с помощью семантики значений. Это означает, что объекты неявно копируются в различных контекстах, и мы должны понимать, что на самом деле означает копирование объекта.

Рассмотрим простой пример:

class person
{
    std::string name;
    int age;

public:

    person(const std::string& name, int age) : name(name), age(age)
    {
    }
};

int main()
{
    person a("Bjarne Stroustrup", 60);
    person b(a);   // What happens here?
    b = a;         // And here?
}

(Если вас озадачивает часть name(name), age(age), это называется списком инициализаторов участников.)

Специальные функции-члены

Что значит скопировать person объект? Функция main показывает два различных сценария копирования. Инициализация person b(a); выполняется конструктором копирования. Его задача - создать новый объект на основе состояния существующего объекта. Присваивание b = a выполняется оператором присваивания копии. Его работа обычно немного сложнее, потому что целевой объект уже находится в некотором допустимом состоянии, с которым нужно работать.

Поскольку мы сами не объявили ни конструктор копирования, ни оператор присваивания (ни деструктор), они неявно определены для нас. Цитата из стандарта:

Конструктор копирования [...] и оператор присваивания копии, [...] и деструктор являются специальными функциями-членами. [Примечание: Реализация неявно объявляет эти функции-члены для некоторых типов классов, если программа не объявляет их явно. Реализация неявно определяет их, если они используются. [...] конец сообщения] [n3126.pdf, раздел 12 §1]

По умолчанию копирование объекта означает копирование его членов:

Неявно определенный конструктор копирования для класса X, не являющегося объединением, выполняет поэлементное копирование своих подобъектов. [n3126.pdf раздел 12.8 §16]

Неявно определенный оператор присваивания копии для класса X, не являющегося объединением, выполняет поэлементное присваивание копий его подобъектам. [n3126.pdf раздел 12.8 §30]

Неявные определения

Неявно определенные специальные функции-члены для person выглядят следующим образом:

// 1. copy constructor
person(const person& that) : name(that.name), age(that.age)
{
}

// 2. copy assignment operator
person& operator=(const person& that)
{
    name = that.name;
    age = that.age;
    return *this;
}

// 3. destructor
~person()
{
}

Последовательное копирование - это именно то, что нам нужно в этом случае: name и age копируются, поэтому мы получаем самодостаточный, независимый person объект. Неявно определенный деструктор всегда пуст. В данном случае это тоже нормально, поскольку мы не получили никаких ресурсов в конструкторе. Деструкторы членов неявно вызываются после завершения деструктора person:

После выполнения тела деструктора и уничтожения любых автоматических объектов, размещенных в теле, деструктор для класса X вызывает деструкторы для [...] прямых членов X [n3126.pdf 12.4 §6]

Управление ресурсами

Итак, когда мы должны явно объявить эти специальные функции-члены? Когда наш класс управляет ресурсом, то есть когда объект класса отвечает за этот ресурс. Обычно это означает, что ресурс приобретается в конструкторе (или передается в конструктор) и освобождается в деструкторе.

Вернемся в прошлое, к предстандартному C ++. Не существовало такой вещи, как std::string, и программисты были влюблены в указатели. Класс person мог бы выглядеть так:

class person
{
    char* name;
    int age;

public:

    // the constructor acquires a resource:
    // in this case, dynamic memory obtained via new[]
    person(const char* the_name, int the_age)
    {
        name = new char[strlen(the_name) + 1];
        strcpy(name, the_name);
        age = the_age;
    }

    // the destructor must release this resource via delete[]
    ~person()
    {
        delete[] name;
    }
};

Даже сегодня люди по-прежнему пишут классы в этом стиле и попадают в затруднительное положение: Я втолкнул человека в вектор, и теперь у меня сумасшедшие ошибки памяти! Помните, что по умолчанию копирование объекта означает копирование его членов, но копирование члена name просто копирует указатель, не массив символов, на который он указывает! Это имеет несколько неприятных последствий:

1. Изменения через a можно увидеть через b.
2. После уничтожения b a.name становится висящим указателем.
3. Если a уничтожается, удаление зависшего указателя приводит к неопределенному поведению.
4. Поскольку присваивание не принимает во внимание то, на что name указывал перед присваиванием, рано или поздно вы получите повсюду утечки памяти.

Явные определения

Поскольку поэлементное копирование не дает желаемого эффекта, мы должны явно определить конструктор копирования и оператор присваивания копии, чтобы сделать глубокие копии массива символов:

// 1. copy constructor
person(const person& that)
{
    name = new char[strlen(that.name) + 1];
    strcpy(name, that.name);
    age = that.age;
}

// 2. copy assignment operator
person& operator=(const person& that)
{
    if (this != &that)
    {
        delete[] name;
        // This is a dangerous point in the flow of execution!
        // We have temporarily invalidated the class invariants,
        // and the next statement might throw an exception,
        // leaving the object in an invalid state :(
        name = new char[strlen(that.name) + 1];
        strcpy(name, that.name);
        age = that.age;
    }
    return *this;
}

Обратите внимание на разницу между инициализацией и назначением: мы должны удалить старое состояние перед назначением name, чтобы предотвратить утечку памяти. Также мы должны защитить себя от присвоения формы x = x. Без этой проверки delete[] name удалит массив, содержащий строку source, потому что, когда вы пишете x = x, и this->name, и that.name содержат один и тот же указатель.

Исключительная безопасность

К сожалению, это решение не сработает, если new char[...] вызовет исключение из-за нехватки памяти. Одно из возможных решений - ввести локальную переменную и изменить порядок операторов:

// 2. copy assignment operator
person& operator=(const person& that)
{
    char* local_name = new char[strlen(that.name) + 1];
    // If the above statement throws,
    // the object is still in the same state as before.
    // None of the following statements will throw an exception :)
    strcpy(local_name, that.name);
    delete[] name;
    name = local_name;
    age = that.age;
    return *this;
}

Это также позаботится о самостоятельном назначении без явной проверки. Еще более надежным решением этой проблемы является идиома копирования и обмена, но я не буду вдаваться в подробности исключения. безопасность здесь. Я упомянул исключения только для того, чтобы подчеркнуть следующее: Написание классов, управляющих ресурсами, затруднено.

Некопируемые ресурсы

Некоторые ресурсы нельзя или не следует копировать, например дескрипторы файлов или мьютексы. В этом случае просто объявите конструктор копирования и оператор присваивания копии как private, не давая определения:

private:

    person(const person& that);
    person& operator=(const person& that);

В качестве альтернативы вы можете унаследовать от boost::noncopyable или объявить их удаленными (в C ++ 11 и выше):

person(const person& that) = delete;
person& operator=(const person& that) = delete;

Правило трех

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

Если вам нужно явно объявить деструктор, конструктор копирования или оператор присваивания копии, вам, вероятно, потребуется явно объявить все три из них.

(К сожалению, это правило не соблюдается ни стандартом C ++, ни каким-либо известным мне компилятором.)

Правило пяти

Начиная с C ++ 11, у объекта есть две дополнительные специальные функции-члены: конструктор перемещения и присваивание перемещения. Правило пяти государств также реализует эти функции.

Пример с подписями:

class person
{
    std::string name;
    int age;

public:
    person(const std::string& name, int age);        // Ctor
    person(const person &) = default;                // 1/5: Copy Ctor
    person(person &&) noexcept = default;            // 4/5: Move Ctor
    person& operator=(const person &) = default;     // 2/5: Copy Assignment
    person& operator=(person &&) noexcept = default; // 5/5: Move Assignment
    ~person() noexcept = default;                    // 3/5: Dtor
};

Правило нуля

Правило 3/5 также называется правилом 0/3/5. Нулевая часть правила гласит, что вам разрешено не писать какие-либо специальные функции-члены при создании вашего класса.

Совет

В большинстве случаев вам не нужно управлять ресурсом самостоятельно, потому что существующий класс, такой как std::string, уже делает это за вас. Просто сравните простой код, использующий элемент std::string, с запутанной и подверженной ошибкам альтернативой, использующей char*, и вы убедитесь. Пока вы держитесь подальше от необработанных элементов-указателей, правило трех вряд ли будет касаться вашего собственного кода.

Правило трех - это практическое правило для C ++, в основном говоря

Если вашему классу нужен какой-либо из

• конструктор копирования,
• оператор присваивания,
• или деструктор,

определены явно, то, вероятно, потребуются все три из них.

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

Если нет хорошей семантики для копирования ресурса, которым управляет ваш класс, рассмотрите возможность запрета копирования, объявив (не определение) конструктора копирования и оператора присваивания как private.

(Обратите внимание, что предстоящая новая версия стандарта C ++ (который представляет собой C ++ 11) добавляет семантику перемещения в C ++, что, вероятно, изменит правило трех. Однако я слишком мало знаю об этом, чтобы написать раздел C ++ 11 о правиле трех.)

Закон большой тройки такой, как указано выше.

Простой пример на простом английском языке проблемы, которую он решает:

Деструктор не по умолчанию

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

Вы можете подумать, что работа сделана.

Проблема будет в том, что если копия вашего объекта сделана, то копия будет указывать на ту же память, что и исходный объект.

Как только один из них удаляет память в своем деструкторе, другой будет иметь указатель на недопустимую память (это называется висячим указателем), когда он попытается его использовать, все станет волосатым.

Поэтому вы пишете конструктор копирования, чтобы он выделял новым объектам их собственные фрагменты памяти для уничтожения.

Оператор присваивания и конструктор копирования

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

Это означает, что новый объект и старый объект будут указывать на один и тот же фрагмент памяти, поэтому, когда вы измените его в одном объекте, он будет изменен и для другого объекта. Если один объект удалит эту память, другой продолжит попытки ее использовать - eek.

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

В основном, если у вас есть деструктор (а не деструктор по умолчанию), это означает, что определенный вами класс имеет некоторое выделение памяти. Предположим, что класс используется снаружи каким-то клиентским кодом или вами.

    MyClass x(a, b);
    MyClass y(c, d);
    x = y; // This is a shallow copy if assignment operator is not provided

Если MyClass имеет только некоторые примитивно типизированные члены, оператор присваивания по умолчанию будет работать, но если у него есть элементы-указатели и объекты, не имеющие операторов присваивания, результат будет непредсказуемым. Поэтому мы можем сказать, что если есть что удалить в деструкторе класса, нам может понадобиться оператор глубокого копирования, что означает, что мы должны предоставить конструктор копирования и оператор присваивания.

Что означает копирование объекта? Есть несколько способов копирования объектов - давайте поговорим о двух типах, о которых вы, скорее всего, имеете в виду: глубокое и поверхностное копирование.

Поскольку мы находимся на объектно-ориентированном языке (или, по крайней мере, так предполагаем), допустим, у вас есть выделенная часть памяти. Поскольку это объектно-ориентированный язык, мы можем легко ссылаться на блоки памяти, которые мы выделяем, потому что они обычно являются примитивными переменными (целые числа, символы, байты) или определенными нами классами, состоящими из наших собственных типов и примитивов. Допустим, у нас есть следующий класс Car:

class Car //A very simple class just to demonstrate what these definitions mean.
//It's pseudocode C++/Javaish, I assume strings do not need to be allocated.
{
private String sPrintColor;
private String sModel;
private String sMake;

public changePaint(String newColor)
{
   this.sPrintColor = newColor;
}

public Car(String model, String make, String color) //Constructor
{
   this.sPrintColor = color;
   this.sModel = model;
   this.sMake = make;
}

public ~Car() //Destructor
{
//Because we did not create any custom types, we aren't adding more code.
//Anytime your object goes out of scope / program collects garbage / etc. this guy gets called + all other related destructors.
//Since we did not use anything but strings, we have nothing additional to handle.
//The assumption is being made that the 3 strings will be handled by string's destructor and that it is being called automatically--if this were not the case you would need to do it here.
}

public Car(const Car &other) // Copy Constructor
{
   this.sPrintColor = other.sPrintColor;
   this.sModel = other.sModel;
   this.sMake = other.sMake;
}
public Car &operator =(const Car &other) // Assignment Operator
{
   if(this != &other)
   {
      this.sPrintColor = other.sPrintColor;
      this.sModel = other.sModel;
      this.sMake = other.sMake;
   }
   return *this;
}

}

Глубокая копия - это если мы объявляем объект, а затем создаем полностью отдельную копию объекта ... мы получаем 2 объекта в 2 полных наборах памяти.

Car car1 = new Car("mustang", "ford", "red");
Car car2 = car1; //Call the copy constructor
car2.changePaint("green");
//car2 is now green but car1 is still red.

А теперь сделаем что-нибудь странное. Скажем, car2 либо запрограммирован неправильно, либо преднамеренно предназначен для совместного использования фактической памяти, из которой сделан car1. (Обычно это ошибка, и в классах это обычно одеяло, под которым оно обсуждается.) Представьте, что каждый раз, когда вы спрашиваете о car2, вы действительно разрешаете указатель на пространство памяти car1 ... это более или менее то, что мелкая копия является.

//Shallow copy example
//Assume we're in C++ because it's standard behavior is to shallow copy objects if you do not have a constructor written for an operation.
//Now let's assume I do not have any code for the assignment or copy operations like I do above...with those now gone, C++ will use the default.

 Car car1 = new Car("ford", "mustang", "red"); 
 Car car2 = car1; 
 car2.changePaint("green");//car1 is also now green 
 delete car2;/*I get rid of my car which is also really your car...I told C++ to resolve 
 the address of where car2 exists and delete the memory...which is also
 the memory associated with your car.*/
 car1.changePaint("red");/*program will likely crash because this area is
 no longer allocated to the program.*/

Поэтому, независимо от того, на каком языке вы пишете, будьте очень осторожны с тем, что вы имеете в виду, когда речь идет о копировании объектов, потому что в большинстве случаев вам нужна глубокая копия.

Что такое конструктор копирования и оператор присваивания копии? Я уже использовал их выше. Конструктор копирования вызывается, когда вы вводите код, например Car car2 = car1;. По сути, если вы объявляете переменную и назначаете ее в одной строке, то при вызове конструктора копирования. Оператор присваивания - это то, что происходит, когда вы используете знак равенства --_ 5_. Замечание car2 не объявлено в том же заявлении. Два фрагмента кода, которые вы пишете для этих операций, вероятно, очень похожи. Фактически, в типичном шаблоне проектирования есть еще одна функция, которую вы вызываете, чтобы установить все, как только вы будете удовлетворены первоначальным копированием / назначением законным - если вы посмотрите на длинный код, который я написал, функции почти идентичны.

Когда мне нужно заявить о них самому? Если вы не пишете код, предназначенный для совместного использования или для производства, вам действительно нужно объявить их только тогда, когда они вам понадобятся. Вам действительно нужно знать, что делает ваш язык программы, если вы решили использовать его «случайно» и не сделали этого, т. Е. вы получаете компилятор по умолчанию. Например, я редко использую конструкторы копирования, но переопределения оператора присваивания очень распространены. Знаете ли вы, что вы также можете переопределить, что означают сложение, вычитание и т. Д.?

Как я могу предотвратить копирование моих объектов? Разумным началом является переопределение всех способов, которыми вам разрешено выделять память для вашего объекта, с помощью частной функции. Если вы действительно не хотите, чтобы люди копировали их, вы можете сделать его общедоступным и предупредить программиста, выдав исключение, а также не копируя объект.

Когда мне нужно заявить о них самому?

Правило трех гласит, что если вы объявите любой из

1. конструктор копирования
2. оператор присваивания копий
3. деструктор

тогда вы должны объявить все три. Это выросло из наблюдения, что необходимость перенять смысл операции копирования почти всегда проистекает из класса, выполняющего какое-то управление ресурсами, и это почти всегда означало, что

• какое бы управление ресурсами ни выполнялось в одной операции копирования, вероятно, необходимо было выполнить в другой операции копирования и

• деструктор класса также будет участвовать в управлении ресурсом (обычно освобождая его). Классическим управляемым ресурсом была память, и именно поэтому все классы стандартной библиотеки, которые управляют памятью (например, контейнеры STL, которые выполняют динамическое управление памятью), объявляют «большую тройку»: как операции копирования, так и деструктор.

Следствием правила трех является то, что наличие объявленного пользователем деструктора указывает на то, что простое поэлементное копирование вряд ли будет подходящим для операций копирования в классе. Это, в свою очередь, предполагает, что если класс объявляет деструктор, операции копирования, вероятно, не должны генерироваться автоматически, потому что они не будут делать правильные вещи. В то время, когда был принят C ++ 98, важность этой аргументации не была полностью оценена, поэтому в C ++ 98 наличие деструктора, объявленного пользователем, не повлияло на готовность компиляторов генерировать операции копирования. Это по-прежнему имеет место в C ++ 11, но только потому, что ограничение условий, при которых генерируются операции копирования, нарушит слишком много унаследованного кода.

Как я могу предотвратить копирование моих объектов?

Объявите конструктор копирования и оператор присваивания копии как спецификатор частного доступа.

class MemoryBlock
{
public:

//code here

private:
MemoryBlock(const MemoryBlock& other)
{
   cout<<"copy constructor"<<endl;
}

// Copy assignment operator.
MemoryBlock& operator=(const MemoryBlock& other)
{
 return *this;
}
};

int main()
{
   MemoryBlock a;
   MemoryBlock b(a);
}

Начиная с C ++ 11, вы также можете объявить конструктор копирования и оператор присваивания удаленными.

class MemoryBlock
{
public:
MemoryBlock(const MemoryBlock& other) = delete

// Copy assignment operator.
MemoryBlock& operator=(const MemoryBlock& other) =delete
};


int main()
{
   MemoryBlock a;
   MemoryBlock b(a);
}

Многие из существующих ответов уже касаются конструктора копирования, оператора присваивания и деструктора. Однако в post C ++ 11 введение семантики перемещения может расширить это значение за пределы 3.

Недавно Майкл Клесс выступил с докладом на эту тему: http://channel9.msdn.com/events/CPP/C-PP-Con-2014/The-Canonical-Class

Правило трех в C ++ - это фундаментальный принцип проектирования и разработки трех требований, согласно которым при наличии четкого определения в одной из следующих функций-членов программист должен определить две другие функции-члены вместе. А именно, необходимы следующие три функции-члены: деструктор, конструктор копирования, оператор присваивания копии.

Конструктор копирования в C ++ - это специальный конструктор. Он используется для создания нового объекта, который является новым объектом, эквивалентным копии существующего объекта.

Оператор присваивания копирования - это специальный оператор присваивания, который обычно используется для указания существующего объекта другим объектам того же типа.

Вот быстрые примеры:

// default constructor
My_Class a;

// copy constructor
My_Class b(a);

// copy constructor
My_Class c = a;

// copy assignment operator
b = a;