Чем отличается конструктор копирования от оператора присваивания
Перейти к содержимому

Чем отличается конструктор копирования от оператора присваивания

  • автор:

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

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

SomeClass A = B; 

А здесь только оператор присваивания:

Matrix A, B; A = B; 

Если так, то чем отличается конструктор копирования от оператора присваивания, почему нельзя заменить один другим и зачем в С++ они разделены?

Отслеживать
9,426 4 4 золотых знака 41 41 серебряный знак 57 57 бронзовых знаков
задан 2 июн 2017 в 16:18
671 4 4 серебряных знака 17 17 бронзовых знаков

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

2 июн 2017 в 16:46

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

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

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

Это две совершенно разные задачи.

В общем случае, работа оператора присваивания состоит из двух этапов: корректно убрать из объекта старое содержимое, а затем корректно скопировать в него новое содержимое. Работа же конструктора копирования не имеет первого этапа, ибо никакого старого содержимого в этот момент в объекте нет.

То есть упрощенно можно сказать, что конструктор копирования — это «половинка» оператора присваивания.

Копирование конструкторов и операторов назначения копирования (C++)

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

Как при операции назначения, так и при операции инициализации выполняется копирование объектов.

  • Назначение: когда значение одного объекта назначается другому объекту, первый объект копируется во второй объект. Таким образом, этот код копирует значение b в a :
Point a, b; . a = b; 

Можно определить семантику копии объектов типа класса. Рассмотрим для примера такой код:

TextFile a, b; a.Open( "FILE1.DAT" ); b.Open( "FILE2.DAT" ); b = a; 

Предыдущий код может означать «копирование содержимого FILE1. DAT в FILE2. DAT или может означать «игнорировать FILE2″. DAT и сделайте b второй дескриптор в FILE1.DAT». Необходимо присоединить соответствующую семантику копирования к каждому классу следующим образом:

  • Используйте оператор operator= назначения, который возвращает ссылку на тип класса и принимает один параметр, передаваемый по const ссылке, например ClassName& operator=(const ClassName& x); .
  • Используйте конструктор копирования.

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

Конструктор копирования принимает аргумент типа ClassName& , где ClassName — имя класса. Рассмотрим пример.

// spec1_copying_class_objects.cpp class Window < public: Window( const Window& ); // Declare copy constructor. Window& operator=(const Window& x); // Declare copy assignment. // . >; int main()

По возможности сделайте тип аргумента const ClassName& конструктора копирования. Это предотвращает случайное изменение скопированного объекта конструктором копирования. Он также позволяет копировать из const объектов.

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

Конструкторы копирования, созданные компилятором, например определяемые пользователем конструкторы копирования, имеют один аргумент типа «ссылка на имя класса». Исключение заключается в том, что все базовые классы и классы-члены имеют конструкторы копирования, объявленные как принимающие один аргумент типа const class-name&>. В таком случае аргумент конструктора копирования, созданного компилятором, также const является .

Если тип аргумента конструктору копирования не const является, инициализация путем копирования const объекта создает ошибку. Обратный аргумент не имеет значения true: если аргумент const имеет значение, можно инициализировать, скопировав объект, который не const является.

Операторы назначения, созданные компилятором, соответствуют тому же шаблону const . Они принимают один аргумент типа ClassName& , если операторы назначения во всех базовых и классах членов не принимают аргументы типа const ClassName& . В этом случае созданный оператор назначения для класса принимает const аргумент.

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

Последствия аналогичны конструктору копирования. Если тип аргумента не const является, назначение из const объекта создает ошибку. Обратный аргумент не имеет значения: если const значение присваивается значению, которое не const является, назначение завершается успешно.

Дополнительные сведения о перегруженных операторах назначения см. в разделе «Назначение».

Чем отличается конструктор копирования от оператора присваивания

Классы: копирование и присваивание

В этой части мы продолжим начатое в статье Элементы класса, о которых всегда необходимо помнить обсуждение конструктора копий (copy constructor) и операции присваивания (assignment operator). Или, вернее, начнем подробное рассмотрение весьма нетривиальной проблемы, каковой на самом деле является копирование и присваивание в классах.
Эти два элемента вполне заслужили отдельного рассмотрения. Создание программ на C++ без понимания внутренней сущности этих функций-членов сродни бегу на марафонскую дистанцию без тренировки (возможно, это не самое удачное сравнение, проще говоря, эти функции очень важны).
Конструктор копий служит для создания новых объектов из существующих. Операция присваивания нужна для того, чтобы сделать один существующий объект эквивалентным другому существующему.
Что означает создать копию? Как один из вариантов, это означает присваивание значений элементов одного объекта элементам другого. Этот ответ, однако, далеко не полон. C++ — это язык, который практически не ограничивает выбор пути реализации программы. И способ создания копий объектов — не исключение из этого правила.
Иногда для копирования классов достаточно просто привести один объект в то же состояние, что и другой. Это весьма просто, и мы увидим, как это делается. Однако если вашему приложению требуются другие методы копирования, C++ не станет создавать их за вас, хотя, если вы не напишете эти функции, компилятор сделает это сам. Правда, результат при этом может существенно отличаться от того, что вам бы хотелось.

  • Понятие копирования
  • Копирование буквальное и развернутое
  • Когда выполняется копирование
  • Разница между копированием и присваиванием
  • Положение в классах
  • Блокирование копирования и присваивания
  • Реализация копирования через присваивание
  • Копирование и присваивание в производных классах

Здесь мы поговорим об одном из аспектов внутреннего функционирования программ, написанных на C++ — о копировании. Копирование в программах на C++ происходит, прямо или косвенно, буквально на каждом шагу. Причем, не всегда с первого взгляда очевидно, где происходит копирование, а где нет.
Мы начнем с рассмотрения синтаксиса интересующего нас предмета, а затем попробуем углубиться в его осмысление.

Определение конструктора копий

Конструктор копий используется для создания новых объектов из уже существующих. Это означает, что, так же как для других конструкторов, новый объект еще не существует к моменту его вызова. Однако только конструктору копий объект передается как аргумент по ссылке. Итак, синтаксис конструктора копий прост. Конструктор копий произвольного класса X выглядит так:
Х(const X&) ; // конструктор копий класса Х
Так как конструктор копий — это все таки конструктор, то он должен иметь имя, совпадающее с именем класса (не забывайте с учетом регистра символов). Назначение конструктора копий — дублирование объекта-аргумента для построения нового объекта. Одно из основных правил: если аргумент не должен изменяться, то его следует передавать как константу. В то же время, если аргумент не описан как константа, то нельзя копировать объекты-константы. Переменный объект всегда можно передать как постоянный аргумент, но не наоборот.
Вторая часть объявления аргумента, X, проста: копируется объект того же самого типа. Аргумент в целом читается как «постоянная ссылка на X». Ссылка существенна по нескольким соображениям. В первую очередь потому, что при передаче адреса объекта не создается копия вызывающего объекта (в отличие от передачи аргумента по значению). Если вам чудится здесь какой-то подвох, то будьте внимательны.
Работа конструктора копий — создание ранее не существовавшего объекта из уже существующего, а передача по значению (без использования операции получения адреса) требует создания копии аргумента, значит мы получаем бесконечную рекурсию. Точнее: при передаче объекта по значению создается его копия, если это произойдет в конструкторе копий, то он будет вызывать сам себя, пока не исчерпает все ресурсы системы.

  • Имя функции точно совпадает с именем класса.
  • Аргумент объявляется постоянным, что позволяет принимать как постоянные, так и переменные аргументы.
  • Тип аргумента является типом класса.
  • Аргумент передается по ссылке, т. е. с помощью операции получения адреса.
  • Среди членов класса нет указателей (*).
  • Среди членов класса нет ссылок (&).

class X
public:
Х(); // конструктор по умолчанию
virtual ~X(); // виртуальный деструктор
// Конструктор копии и операция присваивания не определены
// намеренно. Класс содержит только данные, размещаемые
// в стеке, поэтому предопределенных конструктора копий
//и операции присваивания достаточно.
private:
int data;
char moreData;
float no_Pointers;
>;

Если хотя бы одно из названных условий не выполняется, то следует определить как конструктор копий, так и операцию присваивания.

Определение операции присваивания

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

X& operator=(const X&); // синтаксис операции присваивания для
// произвольного класса

Присваивание — это операция, значит мы должны использовать ключевое слово operator и соответствующий символ операции. Так как C++ допускает цепочки присваивания
а = b = с = d; // C++ допускает последовательные присваивания,
// так что это свойство надо сохранить
то необходимо возвращать ссылку на объект; в противном случае цепочка прервется.
Итак, оператор-функция принимает постоянную ссылку, а возвращает ссылку на объект. Использование ключевого слова const позволяет функции работать как с постоянными объектами, так и с переменными.

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

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

POINT Pix;
Pix = Pix; // присваивание самому себе

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

POINT& POINT::operator=(const POINT& rhs)
if(this == &rhs) return *this; // проверка на присваивание себе
else < X=rhs.X; Y=rhs.Y; >//то, что делает оператор полезного
return *this; // возврат ссылки на объект
>

Сейчас мы попробуем в ней разобраться, благо для всех операций присваивания проверка на присваивание себе совершенно одинакова.
Оператор if(this == &rhs) проверяет, не совпадает ли аргумент с самим объектом. Указатель this содержит адрес вызывающего объекта, &rhs читается как «адрес rhs». Таким образом, сравниваются два адреса. Если они эквивалентны (==), то это один и тот же объект. В этом случае, в полном соответствии с требованием возврата ссылки на объект, просто возвращаем *this (заметьте, что в конце функции делается то же самое) и выходим из функции.
Вспомните, что this — это указатель. Значение указателя — это адрес. Чтобы получить значение указателя, его следует разыменовывать. Разыменование указателя выглядит так: *ptr. Указатель this разыменовывается точно так же: *this.
Помещая эти две строки в начале и в конце тела операции присваивания, мы уменьшаем вероятность возникновения утечек памяти из-за этой операции.
Если вы запомнили приведенный здесь синтаксис копирования и присваивания и, определяя новый класс, сразу будете определять и их тоже, то это уже полдела.

Зачем C++ требует определения этих функций-членов?

Язык C++ не слишком сильно ограничивает свободу программистов в методах разработки программного обеспечения. В частности, он не навязывает вам способы копирования и присваивания. Количество и разнообразие ситуаций, в которых происходит копирование объектов, удивительно велико. Для очень простых объектов, состоящих из одного-двух элементов, затраты на копирование незначительны, но для более сложных, таких как графический интерфейс пользователя или комплексные типы данных, оперирующие с динамической памятью, издержки на копирование существенно возрастают.
Во-первых, имейте в виду, что если вы не определите для нового класса конструктор копий, то C++ создаст его сам. Причина заключается в том, что компилятору самому может потребоваться возможность создания копий, значит, эти две функции обязаны быть определены. Во-вторых, вам может потребоваться заблокировать копирование, либо вести подсчет ссылок, или еще что-нибудь. Если вы не создадите эти функции, то C++ создаст для них версии по умолчанию.
Создаваемые компилятором версии обеих этих функций не всегда будут вас удовлетворять. Версии компилятора выполняют буквальное, или поразрядное, копирование. В некоторых случаях это неразумно. Не пожалейте времени на изучение ситуаций, которые могут вам встретиться при разработке программ.

Вот лишь некоторые из бесчисленного множества возможных ситуаций, в которых происходит копирование:

POINT х;
POINT у(х); // Прямой вызов конструктора копий.
POINT х = у; // Выглядит как присваивание, но на самом деле
// вызывает конструктор копий. Почему? См. ниже.
POINT a, b;
a = b; // Вызов операции присваивания
POINT Foo(); // Возврат по значению, вызывает копирование
void Foo(POINT); // Передача по значению, создает копию

Во всех этих случаях выполняется копирование. В ходе выполняемой компилятором оптимизации могут появиться и другие варианты. Это та область, где знание действительно сила, способная помочь вам избежать утечек памяти.
В операторе типа POINT х = у; не вызывается операция присваивания класса POINT, хотя на первый взгляд выглядит это именно так. Причина состоит в том, что операция присваивания — это функция-член, а значит может быть вызвана только для уже существующих объектов, в то время как в этом фрагменте происходит создание нового объекта х.
Если объект создается в той же строке, в которой он выступает в качестве левостороннего аргумента, то вызывается конструктор. Строка

Х х = у; // вызов конструктора копий
эквивалентна строке
Х х(у); // вызов конструктора копий
|что совсем не то же самое, что
Х х, у;
х = у; // вызов операции присваивания

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

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

При написании статьи использованы материалы из книг
P.Kimmel
Using Borland C++ 5
Special Edition
перевод BHV — С.Петербург 1997

C++. Бархатный путь
Марченко А.Л.
Центр Информационных Технологий
www.citmgu.ru

Thinking in C++, 2nd ed. Volume 1
2000 by Bruce Eckel

Если вам интересно, или возникают вопросы пишите, разберемся.
Сергей Малышев (aka Михалыч).

Чем отличается конструктор копирования от оператора присваивания

Скачай курс
в приложении

Перейти в приложение
Открыть мобильную версию сайта

© 2013 — 2023. Stepik

Наши условия использования и конфиденциальности

Get it on Google Play

Public user contributions licensed under cc-wiki license with attribution required

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *