C ++ лаконично: конструкторы, деструкторы и операторы

Вступление

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

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

Давайте предположим, что vehicle не является нулевым, но является допустимым объектом типа Vehicle, и что тип Vehicle является типом класса, а не структурой или чем-то еще.

Давайте рассмотрим предыдущий оператор кода, как если бы это был код C #. В C # объект, на который ссылается транспортное средство, живет где-то в куче, управляемой GC. Предыдущий оператор кода сохраняет ссылку на этот объект в переменной someVehicle, которую он получает из существующей ссылки транспортного средства на объект. Все еще есть только один экземпляр этого объекта с двумя ссылками на него.

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

Сейчас есть две копии, где когда-то была одна. Если у класса Vehicle нет указателя, std :: shared_ptr, ссылки или чего-то подобного в качестве переменной-члена, две копии полностью разделены. Изменение или даже уничтожение одного не окажет никакого влияния на другого.

Конечно, если вы хотите, чтобы someVehicle являлся ссылкой на объект транспортного средства, вы можете немного изменить код и выполнить это. Но что, если бы вы хотели, чтобы какое-то транспортное средство стало транспортным средством, а транспортное средство перестало существовать — было уничтожено, не забрав при этом свои прежние ресурсы? C ++ делает это возможным благодаря так называемому конструктору перемещения и оператору присваивания перемещения.

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

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

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

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

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

Аргументы по умолчанию в объявлениях функций

Конструкторы в C ++ и функции в целом могут иметь аргументы по умолчанию, определенные для некоторых или всех их параметров как часть их объявления (аналогично необязательным аргументам C #). В функциях C ++ все параметры с аргументами по умолчанию должны находиться справа от любого параметра без аргумента по умолчанию в объявлении функции. C ++ не поддерживает именованные аргументы в стиле C #, но вы можете сделать нечто подобное, используя именованный параметр idiom.

Зачем здесь указывать аргументы по умолчанию? Что ж, получается, что если у вас есть конструктор, в котором все параметры имеют аргументы по умолчанию, этот конструктор является конструктором по умолчанию. Это имеет смысл, поскольку, если у вас есть конструктор с подписью Vehicle (VehicleType type = VehicleType :: Car, double odometerReading = 0.0); затем вы можете вызвать этот конструктор с пустыми скобками, и эти аргументы по умолчанию будут применены. Если вы определяете конструктор по умолчанию, у вас может быть только один, независимо от того, у него нет параметров или у всех его параметров есть аргументы по умолчанию.

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

Все это имеет смысл, потому что аргументы по умолчанию делают невозможным различение double Add (double a, double b = 0.0); и двойной Add (double a, int a = 0); учитывая, что оба могут быть названы как double dbl = Add (5.0) ;. Компилятор не может знать, что вы намеревались в этом случае, поэтому он просто не может скомпилировать и отображает сообщение об ошибке.

Параметризованные Конструкторы

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

Конструкторы преобразования

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

Если вы не хотите, чтобы конструктор был конструктором преобразования, вы можете пометить его спецификатором функции: явный. Давайте посмотрим на пример:

Как вы можете видеть, конструктор преобразования позволяет нам создавать s2, непосредственно устанавливая его равным строковому значению. Компилятор видит этот оператор, проверяет, есть ли у SomeClass конструктор преобразования, который получит такое значение, и продолжает вызывать соответствующий конструктор SomeClass. Если бы мы попробовали это с закомментированной строкой sc4, компилятор потерпел бы неудачу, потому что мы использовали явное, чтобы сообщить компилятору, что конструктор, который просто принимает int, не должен рассматриваться как конструктор преобразования, а вместо этого должен быть похож на любой другой параметризованный конструктор.

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

Инициализация данных и базовых классов

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

Пример: InitializationSample \ InitializationSample.cpp

Первое, что мы сделали, это определили две вспомогательные функции, которые пишут сообщения, поэтому мы можем легко следить за порядком, в котором все происходит. Вы заметите, что у каждого из классов есть конструктор, который принимает int, хотя его используют только Y и Z. A, B, C и D даже не указывают имя для int в своих конструкторах параметров int; они просто указывают, что есть параметр int. Это совершенно допустимый код C ++, и мы использовали его вместе с закомментированными именами параметров в _pmain.

Класс A имеет два конструктора: конструктор по умолчанию и параметризованный конструктор, который принимает int. Остальные классы имеют только параметризованные конструкторы, каждый из которых принимает целое число.

• Класс B наследуется от A практически.
• Класс C наследуется из ничего.
• Класс D наследует из ничего.
• Класс Y наследует от B виртуально, непосредственно от D и виртуально от C, в этом порядке.
• Класс Z также наследуется от D напрямую, от B виртуально и от C напрямую, в этом порядке.

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

  Вызов конструктора Y
 Инициализация DEFAULT m_value.
 ПО УМОЛЧАНИЮ Построение A. m_value равно '5'.
 Вызов конструктора B.
 Инициализация м_а.
 Инициализация m_b.
 Построение B. m_a равно 5, а m_b равно 2.
 Вызов конструктора C
 Инициализация m_c.
 Построение C. m_c равно '0'.
 Вызов конструктора D.
 Инициализация m_d.
 Построение D. m_d равно 3.
 Инициализация m_someInt.
 Построение Y. m_someInt равно '0'.
 Y :: GetSomeInt возвращает '0'.
 Уничтожая Y.
 Уничтожая Д.
 Уничтожение С.
 Уничтожая Б.
 Уничтожая А.

 Разрыв между Y и Z.

 Вызов конструктора Z
 Вызов конструктора.
 Инициализация m_value.
 Построение A. m_value равно '20'.
 Вызов конструктора B.
 Инициализация м_а.
 Инициализация m_b.
 Построение B. m_a равно 5, а m_b равно 2.
 Вызов конструктора D.
 Инициализация m_d.
 Построение D. m_d равно 3.
 Вызов конструктора C
 Инициализация m_c.
 Построение C. m_c равно '0'.
 Инициализация m_someInt.
 Построение Z. m_someInt равно '0'.
 Z :: GetSomeInt возвращает '0'.
 Уничтожение З.
 Уничтожение С.
 Уничтожая Д.
 Уничтожая Б.
 Уничтожая А. 

В нашей функции _pmain сначала мы создаем объект типа Y в своей области видимости. Затем мы вызываем его функцию-член GetSomeInt. Это помогает гарантировать, что компилятор не будет оптимизировать создание Y в сборке релиза, если вы возитесь с кодом. Он также служит маркером между строительством и разрушением.

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

Итак, что мы видим? Достаточно много. Давайте сосредоточимся на Y в первую очередь.

Когда мы вызываем конструктор Y, первое, что он делает, это вызывает конструктор по умолчанию для A. Это может показаться ужасно неправильным по нескольким причинам, но на самом деле это правильно. Конструктор Y говорит следовать этому порядку:

1. Инициализировать базовый класс C.
2. Инициализируйте переменную-член Y m_someInt.
3. Инициализировать базовый класс D.
4. Инициализируйте базовый класс B.

Вместо этого мы получаем следующий заказ:

1. Инициализируйте базовый класс A через его конструктор по умолчанию.
2. Инициализируйте базовый класс B.
3. Инициализировать базовый класс C.
4. Инициализировать базовый класс D.
5. Инициализируйте переменную-член Y m_someInt.

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

Ну, мы наследуем от B, прежде чем мы наследуем от других классов. Так может быть, но почему D не инициализируется сразу после B? Это потому, что D наследуется напрямую, а C виртуально наследуется. Виртуалы на первом месте.

Вот правила:

1. Виртуальные базовые классы создаются в порядке слева направо, так как они записаны в списке базовых классов.
2. Если вы не вызываете конкретный конструктор для базового класса, от которого вы фактически унаследовали, компилятор автоматически вызовет его конструктор по умолчанию в соответствующее время.
3. При определении порядка построения базовых классов базовые классы инициализируются перед их производными классами.
4. Когда все виртуальные базовые классы созданы, тогда прямые базовые классы создаются в порядке их объявления слева направо — так же, как виртуальные базовые классы.
5. Когда все его базовые классы созданы, переменная-член класса:
   • По умолчанию инициализируется, если для него нет инициализатора.
   • Значение инициализируется, если инициализатор представляет собой пустой набор скобок.
   • Инициализируется в результате выражения в круглых скобках инициализатора.
6. Переменные-члены инициализируются в порядке, в котором они объявлены в определении класса.
7. После запуска всех инициализаторов в конструкторе будет выполнен любой код внутри тела конструктора.

Когда вы соединяете все эти правила вместе, вы сначала находите порядок B, C, D, потому что B и C имеют виртуальное наследование и, следовательно, предшествуют D. Затем мы добавляем A перед B, потому что B наследуется от A. Таким образом, мы получаем A , B, C, D.

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

Переменные-члены класса B инициализируются в порядке m_a, m_b, потому что это порядок, в котором они объявлены в классе, хотя в конструкторе мы перечисляем их инициализации в обратном порядке.

Делегирующий конструктор

Делегирующий конструктор вызывает другой конструктор того же класса (целевой конструктор). Делегирующий конструктор может иметь только один оператор инициализатора, который является вызовом целевого конструктора. Его тело может иметь заявления; они будут запущены после того, как целевой конструктор будет полностью завершен. Вот пример:

Если вы скомпилируете и запустите этот код с помощью компилятора, такого как GCC, вы увидите следующий вывод:

  Запуск SomeClass :: SomeClass (int).
 Запуск SomeClass :: SomeClass (void).
 SomeClass :: GetValue () = 10 

Копировать конструктор

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

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

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

Если вы не хотите использовать предоставленный компилятором конструктор копирования, или если компилятор не может его предоставить, но вы все равно хотите его иметь, вы можете написать конструктор копирования. Например, возможно, вам нужна более глубокая копия данных, или, возможно, у вашего класса есть std :: unique_ptr, и вы решаете, какой будет его «приемлемая» копия для целей вашего класса. Мы увидим пример этого в ConstructorsSample.

Конструктор копирования обычно должен иметь следующее объявление: SomeClass (const SomeClass &) ;. Чтобы избежать странных ошибок, конструктор всегда должен принимать постоянную ссылку на класс, из которого вы копируете. Нет причины, по которой вы должны изменить класс, из которого вы копируете, в конструкторе копирования. Создание этого const не вредит и обеспечивает некоторые гарантии о вашей работе. Конструктор копирования не должен быть определен как явный.

Оператор назначения копирования

Если вы определяете пользовательский конструктор копирования, вы также должны определить пользовательский оператор назначения копирования. Результатом этого оператора должно быть то, что возвращаемое значение является копией класса, который он копирует. Это то, что вызывается, когда у вас есть такое утверждение, как a = b; где a и b имеют одинаковый тип (например, SomeClass).

Этот оператор является нестатической функцией-членом своего класса, поэтому он вызывается только при назначении копии существующему экземпляру класса. Если у вас было что-то вроде SomeClass a = b; тогда это будет конструкция копирования, а не назначение копирования.

Оператор присваивания копии должен иметь следующую декларацию: SomeClass & operator = (const SomeClass &) ;.

Переместить конструктор

В C ++, если все, что у вас было, это конструктор копирования, и вы хотите передать экземпляр класса в std :: vector (аналог. .NET List <T>) или вернуть его из функции, вам нужно будет сделать копия этого. Даже если вы не собираетесь использовать его снова, вам все равно придется потратить время на копирование. Если вы добавляете много элементов в std :: vector, или если вы написали фабричную функцию, которой вы часто пользуетесь, это сильно ухудшит производительность.

Вот почему C ++ имеет конструктор перемещения. Конструктор перемещения является новым в C ++ 11. Есть некоторые обстоятельства, при которых компилятор предоставит вам их, но обычно вы должны написать свой собственный для классов, для которых он вам понадобится.

Это легко сделать. Обратите внимание, что если вы пишете конструктор перемещения, вам также необходимо написать конструктор копирования. Visual C ++ не применяет это правило в Visual Studio 2012 RC, но оно является частью стандарта языка C ++. Если вам нужно скомпилировать вашу программу с другим компилятором, вы должны убедиться, что вы пишете конструкторы копирования и операторы копирования при написании конструктора перемещения.

Конструктор перемещения обычно должен иметь следующее объявление: SomeClass (SomeClass &&) ;. Он не может быть постоянным (потому что мы будем его модифицировать) или явным.

Функция std::move

Функция std::move помогает писать конструкторы перемещения и операторы присваивания перемещения. Он находится в заголовочном файле <utility>. Он принимает один аргумент и возвращает его в состоянии, подходящем для перемещения. Переданный объект будет возвращен как ссылка rvalue, если семантика перемещения для него не была отключена, в этом случае вы получите ошибку компилятора.

Оператор назначения перемещения

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

Оператор присваивания перемещения должен иметь следующую декларацию: SomeClass & operator = (SomeClass &&) ;.

Удаление семантики копирования или перемещения

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

Второй способ является новым для C ++ 11 и в настоящее время не поддерживается Visual C ++ начиная с Visual Studio 2012 RC. Таким образом, вы объявите функциональность как явно удаляемую. Например, чтобы явно удалить конструктор копирования, вы должны написать SomeClass (const SomeClass &) = delete ;. Тот же синтаксис = delete применяется к операторам присваивания, конструктору перемещения и любым другим функциям. Однако до тех пор, пока Visual C ++ его не поддержит, вам придется придерживаться первого пути.

Деструкторы и Виртуальные Деструкторы

Любой класс, служащий базовым классом другого класса, должен иметь виртуальный деструктор. Вы объявляете виртуальный деструктор, используя ключевое слово virtual (например: virtual ~ SomeClass (void);). Таким образом, если вы приведете объект к одному из его подклассов, а затем впоследствии уничтожите объект, будет вызван соответствующий конструктор, обеспечивающий освобождение всех захваченных классом ресурсов.

Правильные деструкторы имеют решающее значение для идиомы RAII, которую мы вскоре рассмотрим. Вы никогда не должны позволять создавать исключение в деструкторе, если вы не перехватите и не обработаете это исключение в деструкторе. Если есть исключение, которое вы не можете обработать, вы должны выполнить безопасную регистрацию ошибок и затем выйти из программы. Вы можете использовать функцию std::terminate в заголовочном файле <exception> для вызова текущего обработчика завершения. По умолчанию обработчик завершения вызывает функцию abort из заголовка <cstdlib>. Мы обсудим эту функциональность далее в нашем исследовании исключений стандартной библиотеки C ++.

Перегрузка оператора

Перегрузка операторов — мощная, расширенная функция C ++. Вы можете перегружать операторы для каждого класса или глобально с помощью отдельной функции. Почти каждый оператор в C ++ может быть перегружен. Мы вскоре увидим примеры перегрузки операций копирования, назначения перемещения, &, | и | =. Для получения списка других операторов, которые вы можете перегрузить, и как эти перегрузки работают, я рекомендую посетить документацию MSDN по этому вопросу. Это полезная функция, но вы не можете ее использовать. Поиск, когда вам это нужно, часто быстрее, чем попытка запомнить его сразу.

Образец: ConstructorsSample \ Flavor.h

Образец: ConstructorsSample \ Toppings.h

Образец: ConstructorsSample \ IceCreamSundae.h

Образец: ConstructorsSample \ IceCreamSundae.cpp

Образец: ConstructorsSample \ ConstructorsSample.cpp

Вывод

Теперь у вас должно быть базовое понимание конструкторов, деструкторов и операторов в C ++. В следующей статье мы обсудим RAII или Resource Acquisition Is Initialization.

Этот урок представляет собой главу из C ++ Succinctly , бесплатной книги от команды Syncfusion .