Конструктор копирования c кратко
Обновлено: 08.07.2024
Конструктор копирования, деструктор и перегруженный оператор присваивания - незаменимые элементы каждого класса, работающего с динамически выделенной памятью.
1. Конструктор копирования
Конструктор копирования, в отличии от других, в качестве параметра принимает константную ссылку на объект класса.
Данный конструктор вызывается всякий раз, когда создаётся новый объект и для его инициализации берётся значение существующего объекта того же типа. Например, в следующих случаях:
Также конструктор копирования вызывается при передаче объекта в функцию или возврате из неё по значению. Аналогично, с помощью конструктора копирования создаются временные объекты при вычислении арифметических и других операций.
В чём же проблема отсутствия конструктора копирования при выделении в классе динамической памяти? Дело в том, что при отсутствии явного описания, он описывается неявно. Неявный конструктор выполняет поверхностное копирование, т. е. просто дублирует биты из переменных. Таким образом, вместо данных из динамической памяти, копируется адреса на них. В результате, появляется несколько объектов, указывающих на одну область памяти. При изменении этой области через один объект, она также изменится и в другом, что в большинстве случаев является нежелательным поведением. Поэтому в классах, работающих с динамической памятью, необходимо всегда явно объявлять конструктор копирования (см. пример в конце). Как вариант исключения данной проблемы, можно поместить конструктор копирования в приватной области класса, что вовсе запретит выполнять копирование.
2. Перегруженная операция присваивания
Перегруженная операция присваивания используется при присваивании одного объекта другому существующему объекту. Здесь присутствует такая же проблема, что и в конструкторе копирования. К тому же, у объекта, которому присваивается значение, уже может быть выделена динамическая память. Перед присваиванием новых данных, выделенную ранее память необходимо очистить, чтобы не допустить её утечки (см. пример в конце). Также необходимо обработать случай самоприсваивания. В противном случае, данные в динамической памяти просто будут утеряны. Аналогично копированию, присваивание также можно запретить, поместив операцию в приватной области класса.
3. Деструктор
Деструктор вызывается перед удалением объекта и предназначен для освобождения всех используемых ресурсов. Чтобы не допустить утечки памяти, в деструкторе необходимо её очистить.
4. Пример
Стоить отметить, что во всех трёх функциях память должна выделяться и удаляться одинаковым образом. Т. е. нельзя в одном случае использовать delete, а в другом delete[].
Когда новички изучают программирование, первым делом, при рассмотрении новой темы, возникает вопрос – для чего необходима та или иная “вещь” о которой сейчас предстоит узнать. Ответим сразу на этот вопрос: “Зачем нужен конструктор копирования?”.
Конструктор копирования необходим для того, чтобы мы могли создавать “реальные” (а не побитовые) копии для объектов класса. Такая копия объекта может понадобиться в следующих случаях:
- при передаче объекта класса в функцию, как параметра по значению (а не по ссылке);
- при возвращении из функции объекта класса, как результата её работы;
- при инициализации одного объекта класса другим объектом этого класса.
При передаче объекта в функцию как параметра по значению, эта функция начнет работать с его побитовой копией, а не с полями самого объекта. Допустим определены конструктор и деструктор класса. Первый память выделяет, а второй её освобождает. Во время работы функции, указатель побитовой копии объекта указывает на адрес памяти, где расположен оригинальный объект.
В то время, когда работа функции завершается – удаляется и побитовая копия объекта. При ее удалении обязательно сработает определённый деструктор и освободит ту память, что занята объектом-оригиналом. Программа продолжит работу, и при завершении работы, деструктор сработает повторно, пытаясь освободить все тот же отрезок памяти. Это вызовет ошибку программы.
Использование конструктора копирования – прекрасный способ обойти эти ошибки и проблемы. Он создаст “реальную” копию объекта, которая будет иметь личную область динамической памяти.
Конструктор копирования синтаксически выглядит так:
Ниже разберём несложный, но очень показательный пример. В нём будут рассмотрены все 3 случая в которых желательно применять конструктор копирования. Будет создан класс, содержащий конструктор без параметров, конструктор копирования и деструктор.
Нам отлично будет видно сколько раз сработают конструкторы а сколько раз деструктор. Очевидно, что деструктор (если бы он освобождал память) не должен срабатывать большее количество раз, чем конструктор, выделяющий память.
Конструктор без параметров будет вызываться во время создания новых объектов класса. Конструктор копирования – во время создания копий объекта. Деструктор срабатывает при удалении и реального объекта и его копии. В теле функций все описано подробно и не требует дополнительных комментариев.
Запустив программу увидим в консоли следующее:
Посмотрим что программа выдала в консоль. Блок 1 – во время создания нового объекта, сработал конструктор без параметров. В блоке 2 мы разместили функцию showFunc() . Во время передачи в неё “объекта-параметра” по значению, сработал конструктор копирования и создалась “реальная” копия объекта класса OneClass .
При выходе из этой функции сработал деструктор, так как копия объекта уничтожается. Кстати, то, что передача объекта как параметра по значению, вызывает конструктор копирования, служит отличным поводом для передачи объекта по ссылке. Это сэкономит и время и память.
В блоке 3 размещена функция returnObjectFunc() . Так как в её теле прописано создание нового объекта класса OneClass – сначала сработал конструктор без параметров. Далее выполняется код функции и во время возврата объекта в главную функцию main , сработал конструктор копирования. В конце, как и должно быть, деструктор отработал дважды: для объекта и для его реальной копии.
В четвертом блоке, во время объявления и инициализации нового объекта object2 , сработал конструктор копирования. При завершении работы программы деструктор сработал для копии объекта из четвертого блока и для объекта object1 из первого блока.
Если же мы закомментируем /*конструктор копирования*/ в классе и снова запустим программу – увидим, что конструктор без параметров сработает 2 раза, а деструктор – пять раз отработает.
В этой ситуации, если бы деструктор освобождал память — в программе возникла бы ошибка.
Очень рекомендую прочесть тему Конструктор копирования в книге Стивена Прата “Язык программирования С++. Лекции и упражнения. 6-е издание.” Она раскрыта намного глубже и включает все основные нюансы использования конструктора копирования. Подробно рассмотрена операция присваивания = .
Программистам на C++ приходится самостоятельно управлять ресурсами компьютера. В этой статье рассматриваются различные семантики копирования пользовательских объектов, а также способы их правильной реализации.
Под копированием в программировании обычно подразумевается создание идентичного существующему объекта или присваивание значения одного объекта другому. Примитивные типы данных встроены в язык: их количество ограничено, и компилятор в точности знает, как их копировать. Копирование объектов пользовательских типов не всегда является тривиальной задачей: программист должен сам указать компилятору, как копировать экземпляры созданных им классов.
Поверхностное копирование
В C++ это делается с помощью двух специальных функций-членов: конструктора копирования и оператора присваивания копии. Если они не определены, компилятор неявно их генерирует. Поскольку компилятор не осведомлен о внутренних особенностях пользовательского класса, созданные им функции выполняют т.н. неглубокое или поверхностное копирование. Во время этого процесса все поля исходного объекта копируются в целевой одно за другим. Конструктор копирования по умолчанию копирует члены данных объекта, вызывая их конструкторы копирования.
Этот метод отлично работает, когда ни один из членов класса не является сырым указателем. Поскольку конструктор копирует только содержимое указателей вместо данных, на которые те ссылаются, мы получаем два объекта, ссылающихся на один и тот же адрес в памяти. Эти объекты не являются независимыми копиями – если мы изменим один из них, изменение будет видно и в другом.
Что хуже, когда один объект удален или находится вне области видимости, деструктор может освободить общую память, в то время как указатель внутри другого объекта до сих пор на нее ссылается. Ссылающийся на освобожденную память указатель называется висячим. Попытка доступа к освобожденной памяти может привести к неопределенному поведению и породить множество странных или опасных ошибок в программе.
Поверхностное (неглубокое) копирование – простой и дешевый способ, который можно реализовать просто копируя каждый бит объекта. Такой способ известен и как побитовое копирование.
Чтобы продемонстрировать, как работает неглубокое копирование, давайте взглянем на простой класс прямоугольника:
Поскольку этот класс не содержит указателей, созданного компилятором конструктора копирования достаточно для получения независимых копий. В функции main мы создаем новый экземпляр на основе существующего объекта, затем вносим изменения в один объект и отображаем оба. Ниже показан код функции main и результат её работы:
Функция main Результат main
Внесенные в rect1 изменения не отражаются на rect2 . Чтобы увидеть проблемы неглубокого копирования, изменим класс Rectangle так, чтобы он содержал указатели:
Измененный класс Rectangle
Выполнение той же функции main выдает другой результат:
Новый результат main
При изменении rect1 изменилось и содержимое rect2 . Состояние переменных можно выразить с помощью следующей диаграммы:
Диаграмма, иллюстрирующая поверхностное копирование
В отличие от поверхностного, в глубоком копировании посещенные указатели разыменовываются и объекты, на которые они указывают, также копируются. В результате мы имеем две независимых друг от друга копии. Глубокое копирование обходится значительно дороже, поскольку приходится выделять динамическую память для нового объекта, а указатели могут образовывать сложный граф. Кроме того, глубокое копирование – рекурсивный процесс, так как требуется глубокая копия каждого поля.
Глубокое копирование ещё называют почленным. Чтобы реализовать его для нашего класса, нужно более подробно изучить конструктор копирования и оператор присваивания.
Конструктор копирования и оператор присваивания
Конструктор копирования позволяет создать новый экземпляр класса, который является точной копией существующего. Объявление конструктора копирования выглядит следующим образом:
Как и любой другой конструктор он не возвращает значения и обычно принимает в качестве аргумента ссылку (константу) на исходный объект. Строго говоря, внутри конструктора копирования мы можем делать все, что захотим, но чтобы избежать путаницы, рекомендуется реализовать ожидаемое поведение. Также возможно, что нам захочется предотвратить копирование экземпляров классов. В таком случае можно удалить конструктор копирования:
Напомним, что автоматически созданный конструктор копирования выполняет неглубокое копирование. Допустим, класс называется ClassName и имеет поля m 1 , m 2 , m 3 , …, mN . Тогда определение созданного компилятором конструктора выглядит следующим образом:
Конструктор копирования вызывается многократно в разных ситуациях. Самый очевидный случай – когда мы явно создаем новый объект на основе другого экземпляра класса:
Всякий раз, когда объект передается функции по значению, копия аргумента должна быть создана, поэтому конструктор копирования вызывается для инициализации локального аргумента. Именно поэтому нельзя передавать аргументы по значению конструктору копирования – это запустит бесконечную рекурсию.
Стоит отметить, что после удаления конструктора копирования мы не можем больше передавать объекты по значению. Если объект возвращается из функции, конструктор копирования также может быть вызван, хотя компилятор может использовать оптимизацию возвращаемого значения (RVO), чтобы избежать ненужного копирования.
Мы должны помнить, что конструктор копирования по-прежнему является конструктором и используется только для инициализации нового объекта. Но как быть, если мы хотим присвоить значение экземпляра существующему объекту?
Оператор присваивания – это метод, который используется для выполнения присваивания. Как и в случае с конструктором копирования, C++ предоставляет оператор присваивания по умолчанию.
Пример объявления оператора присваивания:
Оператор присваивания и конструктор копирования реализованы аналогично, хотя есть некоторые заметные различия. Во-первых, мы видим, что оператор присваивания возвращает ссылку на экземпляр, потому что в C ++ разрешены объединенные в цепочку присваивания:
В приведённом выше примере оператор присваивания вызывается для rectangle2 с rectangle3 в качестве аргумента. Затем оператор для rectangle1 вызывается со ссылкой, возвращенной из предыдущего вызова в качестве аргумента. Также необходимо учитывать возможность самоприсваивания:
Наконец, в отличие от конструктора копирования, оператор присваивания перезаписывает существующие объекты, ресурсы которых могут быть выделены в куче. Он должен освободить эти ресурсы, чтобы предотвратить утечку памяти.
При определении этих методов нужно всегда помнить о правиле трех. Оно гласит, что если класс определяет один из следующих методов, он должен явно определить все три метода:
- оператор присваивания;
- конструктор копирования;
- деструктор.
Если мы определили деструктор, но не определен конструктор копирования, то деструктор будет вызван дважды для копий: один раз для содержащих копию объектов и во второй раз –для объектов, из которых копируются элементы данных. Поскольку копии не являются независимыми, деструктор дважды освобождает один и тот же участок памяти, что приводит к неопределенному поведению программы.
Реализация глубокого копирования
Ознакомившись с конструктором копирования и оператором присваивания, мы готовы реализовать глубокое копирование для класса Rectangle .
Конструктор копирования для класса Rectangle выглядит следующим образом:
Добавив эти методы в класс, запускаем основную программу, чтобы убедиться в независимости копий:
Новый результат main Диаграмма, иллюстрирующая глубокое копирование
Выводы
Предоставляемые C++ по умолчанию к онструктор копирования и оператор присваивания выполняют поверхностное копирование, которое подходит для классов без указателей. В классах с динамически выделенными членами конструктор копирования и оператор присваивания должны быть определены таким образом, чтобы они выполняли глубокое копирование.
Инициализация нового объекта другим объектом того же типа
К примеру, при инициализации некоторого объекта А типа MyClassобъектом В того же типа происходит создание побитовой копии объекта Bс последующей ее присваиванием объекту А.
Пускай у нас есть класс ClassName, в котором реализован конструктор и деструктор. А в функции mainсоздадим объект типа ClassName, который присвоим новому объекту того же типа:
Результатом работы программы станет:
Конструктор в этом случае вызовется всего лишь однажды при создании объекта cname. А вот деструктор вызовется для обоих объектов во время завершения работы программы. И хорошо если в объектах нет указателей и динамического выделения памяти. Однако если таковое есть, то выскочит ошибка во время выполнения программы. Столь же неприятные вещи могут происходить при передаче объекта в качестве аргумента в функцию и при возврате объекта из функции.
Передача аргументов в функцию
Как известно, в языках С и С++ по умолчанию аргументы в функцию передаются по значению. При этом происходит создание копии аргумента, которая и участвует во всех выражениях внутри функции, не позволяя измениться переменной, что была передана в данную функцию в качестве аргумента. Копия уничтожается при выходе из области видимости функции. Пускай, к примеру, у нас есть класс ClassNameс конструктором по умолчанию и деструктором; и функция function(), в которую передаем объект типа ClassName:
Конструктор вызывается лишь однажды при создании объекта, тогда как деструктор вызывается дважды — при удалении копии и при удалении самого объекта. При передаче объекта в функцию по значению создается его временная побитовая копия. Если исходный объект имеет поле с указателем, под который выделяется необходимый объем динамической памяти, тогда в его побитовой временной копии также окажется клон-указатель, указывающий на ту же область памяти. При выходе из функции копия объекта уничтожается с высвобождением участка памяти, на который указывает указатель. Но деструктору также приходится в завершение программы уничтожать и сам объект, который мы передаем в функцию, и второй раз высвобождать уже удаленную память.
Возврат объекта из функции
Возврат объекта из функции также создает побитовую временную копию возвращаемого объекта. Для этого необходимо, чтобы функция возвращала некоторый объект, а внутри нее должен быть реализован оператор return, который собственно и возвращает значение объекта. Пускай у нас вновь есть класс ClassNameс реализованным конструктором и деструктором. Также пускай у нас есть функция, не принимающая аргументов, но возвращающая объект типа ClassName.
Результатом работы программы станет:
В данном случае конструктор срабатывает дважды — во время создания объекта cnameи во время создания cname1. Казалось бы, деструктор должен был бы сработать также всего лишь дважды при уничтожении обоих объектов. Однако деструкторов оказалось три, а не два. Так случилось потому, что в функции для возврата формируется временная копия возвращаемого объекта. Именно она должна была бы присвоиться объекту, который принимал бы возвращаемое из функции значение. И именно эту копию уничтожает второй по счету деструктор. Таким образом, мы вновь получаем возможность лишнего указателя на одну и ту же область выделенной памяти, что также приведет к необходимости высвобождения одной и той же памяти дважды.
Конструктор копирования
Конструктор копирования получает в качестве параметра ссылку на неизменяемый объект. Реализуем этот конструктор в нашем классеClassName, к примеру, для случая с инициализацией объекта.
Заключение
Читайте также: