Конструктор копирования (C ++) - Copy constructor (C++)

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

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

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

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

Определение

Копирование объектов достигается за счет использования конструктора копирования и оператор присваивания. Конструктор копирования имеет в качестве первого параметра a (возможно, const или летучий ) ссылка в свой собственный тип класса. У него может быть больше аргументов, но с остальными должны быть связаны значения по умолчанию.[1] Следующие допустимые конструкторы копирования для класса Икс:

Икс(const Икс& copy_from_me);Икс(Икс& copy_from_me);Икс(летучий Икс& copy_from_me);Икс(const летучий Икс& copy_from_me);Икс(Икс& copy_from_me, int = 0);Икс(const Икс& copy_from_me, двойной = 1.0, int = 42);...

Следует использовать первый, если нет веской причины использовать один из других. Одно из различий между первым и вторым заключается в том, что временные файлы можно копировать с помощью первого. Например:

Икс а = Икс();     // допустимо для данного X (const X & copy_from_me), но недействительно для данного X (X & copy_from_me)               // потому что второй хочет неконстантный X &               // чтобы создать, компилятор сначала создает временный объект, вызывая конструктор по умолчанию               // of X, затем использует конструктор копирования для инициализации как копию этого временного объекта.                // Временные объекты, созданные во время выполнения программы, всегда имеют тип const. Итак, ключевое слово const необходимо.               // Для некоторых компиляторов обе версии действительно работают, но на такое поведение нельзя полагаться                // потому что это нестандартно.

Другое различие между ними очевидно:

const Икс а;Икс б = а;       // допустимо для данного X (const X & copy_from_me), но недействительно для данного X (X & copy_from_me)               // потому что второй хочет неконстантный X &

В ИКС& форма конструктора копирования используется, когда необходимо изменить скопированный объект. Это очень редко, но его можно увидеть в стандартной библиотеке std :: auto_ptr. Ссылка должна быть предоставлена:

Икс а;Икс б = а;       // допустимо, если определен любой из конструкторов копирования               // поскольку передается ссылка.

Ниже приведены недопустимые конструкторы копирования (Причина - copy_from_me не передается как ссылка):

Икс(Икс copy_from_me);Икс(const Икс copy_from_me);

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

Следующие случаи могут привести к вызову конструктора копирования:

  1. Когда объект возвращается по значению
  2. Когда объект передается (в функцию) по значению в качестве аргумента
  3. Когда объект брошен
  4. Когда объект пойман
  5. Когда объект помещается в список инициализаторов, заключенный в фигурные скобки

Эти дела вместе называются копирование-инициализация и эквивалентны:[2]Т х = а;

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

Операция

Объекту можно присвоить значение одним из двух способов:

  • Явное присваивание в выражении
  • Инициализация

Явное присваивание в выражении

Объект а;Объект б;а = б;       // переводится как Object :: operator = (const Object &), поэтому вызывается a.operator = (b)              // (вызываем простую копию, а не конструктор копирования!)

Инициализация

Объект можно инициализировать любым из следующих способов.

а. Через декларацию

Объект б = а; // переводится как Object :: Object (const Object &) (вызывает конструктор копирования)

б. Через аргументы функции

тип функция(Объект а);

c. Через возвращаемое значение функции

Объект а = функция();

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

Конструктор неявного копирования класса вызывает конструкторы базового копирования и копирует его члены средствами, соответствующими их типу. Если это тип класса, вызывается конструктор копирования. Если это скалярный тип, используется встроенный оператор присваивания. Наконец, если это массив, каждый элемент копируется способом, соответствующим его типу.[3]

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

Примеры

Эти примеры показывают, как работают конструкторы копирования и почему они иногда требуются.

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

Рассмотрим следующий пример:

#включают <iostream>учебный класс Человек { общественный:  явный Человек(int возраст) : возраст(возраст) {}  int возраст;};int главный() {  Человек Тимми(10);  Человек Салли(15);  Человек timmy_clone = Тимми;  стандартное::cout << Тимми.возраст << " " << Салли.возраст << " " << timmy_clone.возраст            << стандартное::конец;  Тимми.возраст = 23;  стандартное::cout << Тимми.возраст << " " << Салли.возраст << " " << timmy_clone.возраст            << стандартное::конец;}

Выход

10 15 1023 15 10

Как и ожидалось, Тимми был скопирован в новый объект, timmy_clone. Пока Тимми возраст был изменен, timmy_clone's возраст остался прежним. Это потому, что это совершенно разные объекты.

Компилятор сгенерировал для нас конструктор копирования, и его можно было бы записать так:

Человек(const Человек& Другой)     : возраст(Другой.возраст)  // Вызывает конструктор копирования возраста.{}

Итак, когда нам действительно нужен определяемый пользователем конструктор копирования? В следующем разделе мы исследуем этот вопрос.

Пользовательский конструктор копирования

Рассмотрим очень простой динамический массив класс вроде следующего:

#включают <iostream>учебный класс Множество { общественный:  явный Множество(int размер) : размер(размер), данные(новый int[размер]) {}  ~Множество() {    если (данные != nullptr) {      Удалить[] данные;    }  }  int размер;  int* данные;};int главный() {  Множество первый(20);  первый.данные[0] = 25;  {    Множество копировать = первый;    стандартное::cout << первый.данные[0] << " " << копировать.данные[0] << стандартное::конец;  }  // (1)  первый.данные[0] = 10;  // (2)}

Выход

25 25 Ошибка сегментации

Поскольку мы не указали конструктор копирования, компилятор сгенерировал его для нас. Сгенерированный конструктор будет выглядеть примерно так:

Множество(const Множество& Другой)  : размер(Другой.размер), данные(Другой.данные) {}

Проблема с этим конструктором в том, что он выполняет мелкая копия из данные указатель. Он копирует только адрес исходного элемента данных; это означает, что они оба совместно используют указатель на один и тот же фрагмент памяти, что нам не нужно. Когда программа доходит до строки (1), копия вызывается деструктор (потому что объекты в стеке автоматически уничтожаются, когда заканчивается их область действия). Массив деструктор удаляет данные массив оригинала, поэтому при удалении копия данные, поскольку они используют один и тот же указатель, он также удалил первый данные. Линия (2) теперь обращается к недопустимым данным и записывает в них! Это приводит к печально известному ошибка сегментации.

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

// для std :: copy#включают <algorithm>Множество(const Множество& Другой)    : размер(Другой.размер), данные(новый int[Другой.размер]) {  стандартное::копировать(Другой.данные, Другой.данные + Другой.размер, данные); }

Здесь мы создаем новый int массив и копирование в него содержимого. Сейчас же, другие деструктор удаляет только свои данные, а не первый данные. Линия (2) больше не вызовет ошибки сегментации.

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

Копировать конструкторы и шаблоны

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

шаблон <typename А> Множество::Множество(А const& Другой)    : размер(Другой.размер()), данные(новый int[Другой.размер()]) {  стандартное::копировать(Другой.начинать(), Другой.конец(), данные);}

(Обратите внимание, что тип А возможно Множество.) Определяемый пользователем конструктор копирования, не являющийся шаблоном, также должен быть предоставлен для создания массива из массива.

Конструктор побитового копирования

В C ++ нет такого понятия, как «конструктор побитового копирования». Однако созданный по умолчанию конструктор копирования копирует, вызывая конструкторы копирования для членов, а для члена необработанного указателя это копирует необработанный указатель (т.е. не глубокую копию).

Конструктор логической копии

Можно увидеть, что в конструкторе логического копирования для указателя создается новая динамическая переменная-член вместе с копированием значений. [4]

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

Явный конструктор копирования

Явный конструктор копирования - это конструктор, который явно объявляется с помощью явный ключевое слово. Например:

явный Икс(const Икс& copy_from_me);

Он используется для предотвращения копирования объектов при вызове функций или с синтаксисом копирования-инициализации.

Смотрите также

Рекомендации

  1. ^ INCITS ISO IEC 14882-2003 12.8.2. [1] В архиве 8 июня 2007 г. Wayback Machine
  2. ^ ISO /IEC (2003). ISO / IEC 14882: 2003 (E): Языки программирования - C ++ §8.5 Инициализаторы [dcl.init] пункт 12
  3. ^ INCITS ISO IEC 14882-2003 12.8.8. [2] В архиве 8 июня 2007 г. Wayback Machine
  4. ^ Информатика: структурированный подход с использованием C ++, Бехруз А. Форузан и Ричард Ф. Гилберг, рисунок 10-9, страница 507

внешняя ссылка