Что такое правило трех?

Question

Что такое правило трех?

Что означает копирование объекта?
Что такое конструктор копирования и оператор присваивания копии?
Когда я должен объявить их сам?
Как я могу предотвратить копирование моих объектов?

2527

c++ copy-constructor assignment-operator c++-faq rule-of-three

Источник

user252000 13 ноя '10 в 13:27

8 ответов

Решение

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

Если вашему классу нужен какой-либо из
конструктор копирования,
оператор присваивания,
или деструктор,
определяется явно, тогда, вероятно, потребуются все три из них.

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

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

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

559

Источник

user140719 13 ноя '10 в 14:22

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

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

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

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

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

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

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

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

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

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

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

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

174

Источник

user861970 14 май '12 в 14:22

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

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

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

48

Источник

user1678760 31 дек '12 в 19:29

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

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

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; По сути, если вы объявляете переменную и присваиваете ей одну строку, тогда вызывается конструктор копирования. Оператор присваивания - это то, что происходит, когда вы используете знак равенства:car2 = car1;, уведомление car2 не заявлено в том же заявлении. Две части кода, которые вы пишете для этих операций, вероятно, очень похожи. На самом деле типичный шаблон проектирования имеет другую функцию, которую вы вызываете, чтобы установить все, как только вы убедитесь, что первоначальное копирование / присвоение является законным - если вы посмотрите на написанный мной длинный код, функции почти идентичны.

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

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

37

Источник

user1701047 17 окт '12 в 16:37

Когда я должен объявить их сам?

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

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

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

какое бы управление ресурсами ни выполнялось в одной операции копирования, вероятно, необходимо было бы выполнить в другой операции копирования и
деструктор класса также будет участвовать в управлении ресурсом (обычно освобождая его). Классическим ресурсом, которым нужно управлять, была память, и именно поэтому все классы стандартной библиотеки, которые управляют памятью (например, контейнеры 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);
}

29

Источник

user2575399 12 янв '16 в 09:54

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

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

19

Источник

user1380947 07 янв '15 в 05:38

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

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

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

Есть быстрые примеры:

// default constructor
My_Class a;

// copy constructor
My_Class b(a);

// copy constructor
My_Class c = a;

// copy assignment operator
b = a;

12

Источник

user2288882 12 авг '14 в 04:27

Другие вопросы по тегам c++ copy-constructor assignment-operator c++-faq rule-of-three

user252000 13 ноя '10 в 13:27 2010-11-13 13:27 · Accepted Answer · 2010-11-13 13:27

Вступление

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 member просто копирует указатель, а не массив символов, на который он указывает! Это имеет несколько неприятных последствий:

Изменения через a можно наблюдать через b,
однажды b уничтожен, a.name это висячий указатель.
Если a уничтожается, удаление висящего указателя приводит к неопределенному поведению.
Поскольку в задании не учитывается, что 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 удалит массив, содержащий исходную строку, потому что, когда вы пишете 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, объект имеет 2 дополнительные специальные функции-члены: конструктор перемещения и назначение перемещения. Правило пяти государств для реализации этих функций, а также.

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

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

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

Правило нуля

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

Совет

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