Зачем нужен конструктор по умолчанию c

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

При написании своего класса, если я явно не определяю конструктор, то компилятор генерирует его сам. Но возникает вопрос — для чего? Я предположил, что он должен быть всегда, что бы не было никаких ошибок, но я могу сделать так: Constructor() = delete; и класс будет без конструкторов вообще, за исключением конструктора копирования и возможно других. Так для чего тогда компилятор его определяет, если можно и без него обойтись?

Отслеживать
задан 3 мая 2021 в 13:40
n 1 k z z z n 1 k z z z
1,491 6 6 серебряных знаков 23 23 бронзовых знака

Ну а как создать объект? Если нет ни одного конструктора? Как гарантировать его (объекта) корректное состояние?

3 мая 2021 в 13:43

@Harry, я могу ошибаться, но мы же можем удалить все конструкторы (поправьте меня если это не так) и все будет хорошо, разве нет?

3 мая 2021 в 13:52

рекомендую почитать «дизайн и эволюция с++» от Страуструпа. И многие подобные вопросы просто отпадут сами собой.

Классы

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

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

имя класса();
имя класса(тип параметра1 =значение по умолчанию, тип параметра2 =значение по умолчанию, …);

Задача: Такая же, как у любого конструктора – инициализировать все поля.

Назначение: Без этого конструктора невозможно создать массив объектов.

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

class String < int len; char * str; public: String(const char *s=""); // конструктор по умолчанию . >; String::String(const char *s):len(strlen(s)),str(new char[len+1]) < strcpy(str,s); >int main() < String a; //создание строки, используя конструктор по умолчанию String b[100]; // создание массива строк String c(); // это не определение объекта, а объявление функции без параметров. >

Конструкторы (C++)

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

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

class Box < public: // Default constructor Box() <>// Initialize a Box with equal dimensions (i.e. a cube) explicit Box(int i) : m_width(i), m_length(i), m_height(i) // member init list <> // Initialize a Box with custom dimensions Box(int width, int length, int height) : m_width(width), m_length(length), m_height(height) <> int Volume() < return m_width * m_length * m_height; >private: // Will have value of 0 when default constructor is called. // If we didn't zero-init here, default constructor would // leave them uninitialized with garbage values. int m_width< 0 >; int m_length< 0 >; int m_height< 0 >; >;

При объявлении экземпляра класса компилятор выбирает конструктор для вызова на основе правил разрешения перегрузки:

int main() < Box b; // Calls Box() // Using uniform initialization (preferred): Box b2 ; // Calls Box(int) Box b3 ; // Calls Box(int, int, int) // Using function-style notation: Box b4(2, 4, 6); // Calls Box(int, int, int) >

Конструкторы могут быть объявлены как inline , friendexplicit или constexpr .
Конструктор может инициализировать объект, объявленный как const или volatileconst volatile . Объект становится const после завершения конструктора.
Чтобы определить конструктор в файле реализации, присвойте ему полное имя, как и любая другая функция-член: Box::Box()

Списки инициализатора элементов

Конструктор может иметь список инициализаторов элементов, который инициализирует элементы класса перед запуском текста конструктора. (Список инициализаторов элементов не совпадает со списком инициализаторов типа std::initializer_list .)

Предпочесть списки инициализаторов элементов вместо назначения значений в тексте конструктора. Список инициализаторов элементов напрямую инициализирует элементы. В следующем примере показан список инициализатора элементов, состоящий из всех identifier(argument) выражений после двоеточия:

 Box(int width, int length, int height) : m_width(width), m_length(length), m_height(height) <>

Идентификатор должен ссылаться на член класса; он инициализирован со значением аргумента. Аргумент может быть одним из параметров конструктора, вызовом функции или одним std::initializer_list из них.

const элементы и члены ссылочного типа должны быть инициализированы в списке инициализатора элементов.

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

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

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

class Box < public: Box() < /*perform any required default initialization steps*/>// All params have default values Box (int w = 1, int l = 1, int h = 1): m_width(w), m_height(h), m_length(l)<> . >

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

#include using namespace std; class Box < public: int Volume() private: int m_width < 0 >; int m_height < 0 >; int m_length < 0 >; >; int main() < Box box1; // Invoke compiler-generated constructor cout

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

Можно запретить компилятору создавать неявный конструктор по умолчанию, определив его как deleted:

 // Default constructor Box() = delete;

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

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

class myclass<>; int main() < myclass mc(); // warning C4930: prototyped function not called (was a variable definition intended?) >

Это оператор является примером проблемы "Большинство Vexing Parse". Можно интерпретировать myclass md(); как объявление функции или как вызов конструктора по умолчанию. Так как средства синтаксического анализа C++ предпочитают объявления по сравнению с другими вещами, выражение рассматривается как объявление функции. Дополнительные сведения см. в статье Википедии Наиболее неоднозначный анализ.

Если объявлены какие-либо конструкторы, отличные от по умолчанию, компилятор не предоставляет конструктор по умолчанию:

class Box < public: Box(int width, int length, int height) : m_width(width), m_length(length), m_height(height)<>private: int m_width; int m_length; int m_height; >; int main()< Box box1(1, 2, 3); Box box2< 2, 3, 4 >; Box box3; // C2512: no appropriate default constructor available >

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

Box boxes[3]; // C2512: no appropriate default constructor available

Но для инициализации массива объектов Box можно использовать набор списков инициализаторов:

Box boxes[3]< < 1, 2, 3 >, < 4, 5, 6 >, < 7, 8, 9 >>;

Дополнительные сведения см. в статье Инициализаторы.

Конструкторы копии

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

У конструктора копий может быть одна из следующих сигнатур:

 Box(Box& other); // Avoid if possible--allows modification of other. Box(const Box& other); Box(volatile Box& other); Box(volatile const Box& other); // Additional parameters OK if they have default values Box(Box& other, int i = 42, string label = "Box");

При определении конструктора копий необходимо также определить оператор присваивания копированием (=). Дополнительные сведения см. в статьях Присваивание и Конструкторы копий и операторы присваивания копированием.

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

 Box (const Box& other) = delete;

При попытке копирования объекта возвращается ошибка C2280: предпринята попытка ссылки на удаленную функцию.

Конструкторы перемещения

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

Box(Box&& other);

Компилятор выбирает конструктор перемещения, когда объект инициализирован другим объектом того же типа, если другой объект будет уничтожен и больше не нуждается в его ресурсах. В следующем примере показан один случай, когда конструктор перемещения выбирается с помощью разрешения перегрузки. В конструкторе, который вызывает get_Box() , возвращаемое значение будет xvalue (значение с истекающим сроком действия). Поэтому он не назначается какой-либо переменной и поэтому выходит из область. Чтобы создать основу для этого примера, пусть у объекта Box будет большой вектор строк, которые представляют его содержимое. Вместо копирования вектора и его строк конструктор перемещения "крадет" его из значения с истекающим сроком действия box, чтобы вектор теперь принадлежал новому объекту. Необходим только вызов std::move , так как классы vector и string реализуют собственные конструкторы перемещения.

#include #include #include #include using namespace std; class Box < public: Box() < std::cout Box(int width, int height, int length) : m_width(width), m_height(height), m_length(length) < std::cout Box(Box& other) : m_width(other.m_width), m_height(other.m_height), m_length(other.m_length) < std::cout Box(Box&& other) : m_width(other.m_width), m_height(other.m_height), m_length(other.m_length) < m_contents = std::move(other.m_contents); std::cout int Volume() < return m_width * m_height * m_length; >void Add_Item(string item) < m_contents.push_back(item); >void Print_Contents() < for (const auto& item : m_contents) < cout > private: int m_width< 0 >; int m_height< 0 >; int m_length< 0 >; vector m_contents; >; Box get_Box() < Box b(5, 10, 18); // "int,int,int" b.Add_Item("Toupee"); b.Add_Item("Megaphone"); b.Add_Item("Suit"); return b; >int main() < Box b; // "default" Box b1(b); // "copy" Box b2(get_Box()); // "move" cout > ch; // keep window open return 0; >

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

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

Дополнительные сведения о написании нетривиального конструктора перемещения см. в статье Конструкторы перемещения и операторы присваивания перемещением.

Явные конструкторы по умолчанию и удаленные конструкторы

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

class Box2 < public: Box2() = delete; Box2(const Box2& other) = default; Box2& operator=(const Box2& other) = default; Box2(Box2&& other) = default; Box2& operator=(Box2&& other) = default; //. >;

Конструкторы constexpr

Конструктор может быть объявлен как constexpr в следующих случаях:

он либо объявлен как стандартный, либо он удовлетворяет всем условиям для функций constexpr в целом;
у класса нет виртуальных базовых классов;
каждый из параметров является типом литерала;
Текст не является блоком пробной функции;
инициализированы все нестатические члены данных и подобъекты базового класса;
если класс является a) объединением с вариантами членов или б) имеет анонимные объединения, то инициализируется только одно из объединений;
каждый нестатический член данных типа класса, а все подобъекты базового класса имеют конструктор constexpr

Конструкторы списков инициализаторов

 Box(initializer_list list, int w = 0, int h = 0, int l = 0) : m_contents(list), m_width(w), m_height(h), m_length(l) <>

Затем создайте объекты Box следующим образом:

 Box b< "apples", "oranges", "pears" >; // or . Box b2(initializer_list < "bread", "cheese", "wine" >, 2, 4, 6);

Явные конструкторы

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

Box(int size): m_width(size), m_length(size), m_height(size)<>

Можно инициализировать Box следующим образом:

Box b = 42;

Или передать целое значение функции, принимающей объект Box:

class ShippingOrder < public: ShippingOrder(Box b, double postage) : m_box(b), m_postage(postage)<>private: Box m_box; double m_postage; > //elsewhere. ShippingOrder so(42, 10.8);

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

explicit Box(int size): m_width(size), m_length(size), m_height(size)<>

Когда конструктор является явным, эта строка вызывает ошибку компилятора: ShippingOrder so(42, 10.8); . Дополнительные сведения см. в разделе Заданные пользователем преобразования типов (C++).

Порядок строительства

Конструктор выполняет свою работу в следующем порядке.

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

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

#include using namespace std; class Contained1 < public: Contained1() < cout >; class Contained2 < public: Contained2() < cout >; class Contained3 < public: Contained3() < cout >; class BaseContainer < public: BaseContainer() < cout private: Contained1 c1; Contained2 c2; >; class DerivedContainer : public BaseContainer < public: DerivedContainer() : BaseContainer() < cout private: Contained3 c3; >; int main()

Появятся следующие выходные данные.

Contained1 ctor Contained2 ctor BaseContainer ctor Contained3 ctor DerivedContainer ctor

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

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

class Box < public: Box(int width, int length, int height)< m_width = width; m_length = length; m_height = height; >private: int m_width; int m_length; int m_height; >; class StorageBox : public Box < public: StorageBox(int width, int length, int height, const string label&) : Box(width, length, height)< m_label = label; >private: string m_label; >; int main()

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

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

Производные конструкторы и расширенная инициализация агрегатов

Если конструктор базового класса не является открытым, но доступен для производного класса, то вы не можете использовать пустые фигурные скобки для инициализации объекта производного типа в /std:c++17 режиме, а затем в Visual Studio 2017 и более поздних версий.

В следующем примере показана соответствующая реакция на событие в C++14:

struct Derived; struct Base < friend struct Derived; private: Base() <>>; struct Derived : Base <>; Derived d1; // OK. No aggregate init involved. Derived d2 <>; // OK in C++14: Calls Derived::Derived() // which can call Base ctor.

В C++17 Derived теперь считается агрегатным типом. Это означает, что инициализация Base через закрытый конструктор по умолчанию происходит непосредственно как часть расширенного правила агрегатной инициализации. Ранее частный Base конструктор был вызван с помощью Derived конструктора, и он успешно выполнен из-за friend объявления.

В следующем примере показано поведение C++17 в Visual Studio 2017 и более поздних версиях в режиме /std:c++17 :

struct Derived; struct Base < friend struct Derived; private: Base() <>>; struct Derived : Base < Derived() <>// add user-defined constructor // to call with <> initialization >; Derived d1; // OK. No aggregate init involved. Derived d2 <>; // error C2248: 'Base::Base': can't access // private member declared in class 'Base'

Конструкторы классов с множественным наследованием

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

#include using namespace std; class BaseClass1 < public: BaseClass1() < cout >; class BaseClass2 < public: BaseClass2() < cout >; class BaseClass3 < public: BaseClass3() < cout >; class DerivedClass : public BaseClass1, public BaseClass2, public BaseClass3 < public: DerivedClass() < cout >; int main()

Должны выводиться следующие выходные данные:

BaseClass1 ctor BaseClass2 ctor BaseClass3 ctor DerivedClass ctor

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

Делегирующий конструктор вызывает другой конструктор в том же классе для выполнения некоторых операций инициализации. Эта функция полезна при наличии нескольких конструкторов, которые должны выполнять аналогичную работу. Можно написать основную логику в одном конструкторе и вызвать ее из других. В следующем упрощенном примере Box(int) делегирует свою работу Box(int,int,int):

class Box < public: // Default constructor Box() <>// Initialize a Box with equal dimensions (i.e. a cube) Box(int i) : Box(i, i, i) // delegating constructor <> // Initialize a Box with custom dimensions Box(int width, int length, int height) : m_width(width), m_length(length), m_height(height) <> //. rest of class as before >;

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

Наследование конструкторов (C++11)

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

#include using namespace std; class Base < public: Base() < cout Base(const Base& other) < cout explicit Base(int i) : num(i) < cout explicit Base(char c) : letter(c) < cout private: int num; char letter; >; class Derived : Base < public: // Inherit all constructors from Base using Base::Base; private: // Can't initialize newMember from Base constructors. int newMember< 0 >; >; int main() < cout /* Output: Derived d1(5) calls: Base(int) Derived d1('c') calls: Base(char) Derived d3 = d2 calls: Base(Base&) Derived d4 calls: Base()*/

Visual Studio 2017 и более поздних версий: оператор using в режиме и более поздних версиях преобразуется в /std:c++17 область все конструкторы базового класса, кроме тех, которые имеют идентичную сигнатуру конструкторам в производном классе. Как правило, рекомендуется использовать наследующие конструкторы, когда производный класс не объявляет новых элементов данных или конструкторов.

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

template < typename T >class Derived : T < using T::T; // declare the constructors from T // . >;

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

Конструкторы и составные классы

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

class Label < public: Label(const string& name, const string& address) < m_name = name; m_address = address; >string m_name; string m_address; >; class StorageBox : public Box < public: StorageBox(int width, int length, int height, Label label) : Box(width, length, height), m_label(label)<>private: Label m_label; >; int main()< // passing a named Label Label label1< "some_name", "some_address" >; StorageBox sb1(1, 2, 3, label1); // passing a temporary label StorageBox sb2(3, 4, 5, Label< "another name", "another address" >); // passing a temporary label as an initializer list StorageBox sb3(1, 2, 3, ); >

В этом разделе

Конструкторы копий и операторы присваивания копированием
Конструкторы перемещения и операторы присваивания перемещением
Делегирующие конструкторы

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

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

Вот простой пример, как вы ответите на следующий вопрос: сколько значимых типов из .NET Framework содержит конструкторы по умолчанию? Интуитивным ответом кажется "все", и будете не правы, поскольку на самом деле, ни один из значимых типов .NET Framework не содержит конструктора по умолчанию.

Но давайте обо всем по порядку и начнем со сравнения таких понятий, как конструктор по умолчанию (default constructor) и значения по умолчанию (default values).

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

Но когда речь заходит о структурах, то тут все становится немного сложнее. Значением по умолчанию экземпляра значимого типа является «нулевое» представление всех его полей, т.е. все числовые поля равны 0, а все ссылочные поля равны null. С точки зрения языка C# конструктор по умолчанию значимого типа делает тоже самое – он возвращает экземпляр структуры со значением по умолчанию. Это значит, что следующий код является эквивалентным:

Size size1 = new Size(); Size size2 = default(Size);

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

В спецификации языка C# сказано, что пользователю запрещается создавать конструктор по умолчанию явно, поскольку любая структура содержит его неявно. Однако это не совсем так: если мы получим список конструкторов типа Size, то мы не увидим там конструктора без параметров. То что в языке C# называется конструктором по умолчанию, на самом деле является «обнулением» объекта и не является конструктором в привычном смысле этого слова и не содержит никакого специализированного кода в типе Size.

Аналогичное смешивание понятий существует не только при вызове оператора new, но и при инициализации полей структуры в конструкторе. Так, для конструкторов структур применяются те же правила обязательной инициализации всех полей структуры, аналогичные правилам для локальных переменных (definite assignment rules). Это означает, что до завершения тела конструктора все поля структуры должны быть явно или неявно проинициализированы:

struct SomeStruct < private int _i; private double _d; public SomeStruct(int i) : this() // вызываем “конструктор по умолчанию” < _i = i; // Поле _d инициализировано неявно! >>

Вызов this() выглядит в точности как вызов конструктора по умолчанию и предотвращает ошибку компиляции за счет того, что он обнуляет (а значит и инициализирует) все поля структуры. На самом же деле вызов this() превращается все в ту же инструкцию initobj, используемую ранее для получения значения по умолчанию экземпляра структуры.

Такое смешивание понятий конструктора по умолчанию с получением значения по умолчанию для значимых типов является общепринятым на платформе .NET, но не является обязательным. Некоторые языки, как например, «голый» IL или Managed C++, поддерживают полноценные пользовательские конструкторы по умолчанию для значимых типов, которые позволяют инициализировать состояние структуры произвольным образом, а не только значениями по умолчанию.
Хотя язык C# не позволяет создавать конструкторы по умолчанию для структур он позволяет их использовать. Когда компилятор языка C# встречает инструкцию “new SomeType”, то генерируемый код зависит от того, является ли указанный тип классом или структурой, а также от того, содержит ли структура полноценный конструктор по умолчанию или нет:

StringBuilder sb = new StringBuilder(); // 1 Size size = new Size(); // 2 CustomValueType cvt = new CustomValueType(); // 3

В первом случае будет вызван конструктор по умолчанию класса StringBuiilder с помощью инструкции newobj, однако результат создания экземпляра значимого типа зависит от его реализации.

Оба типа Size и CustomValueType являются значимыми типами, при этом тип CustomValueType содержит конструктор по умолчанию (мы рассмотрим позднее, как этого добиться). В строке 2 происходит инициализация переменной size значениями по умолчанию, с помощью инструкции initobj, а в строке 3 происходит вызов конструктора типа CustomValueType с помощью инструкции call CustomValueType..ctor.

Создание структуры с конструктором по умолчанию

Для генерации структуры воспользуемся модулем System.Reflection.Emit, который поддерживает весь необходимый функционал. Процесс создания нового типа начинается создания объекта AssemblyBuilder, внутри которого создается экземпляр DynamicModuleBuilder, в котором уже создается тип. Такой порядок объясняется тем, что сборка, на самом деле, содержит лишь метаданные сборки (зависимости и т.п.) и модули, которые, в свою очередь уже содержат пользовательские типы.

public static Type GenerateValueTypeWithDefaultConstructor(string name, string outputString = "Hello, value type's default ctor!") < // Генерируем сам тип var assemblyName = new AssemblyName("StructEmitter"); var appDomain = AppDomain.CurrentDomain; var assemblyBuilder = appDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave); var moduleBuilder = assemblyBuilder.DefineDynamicModule( assemblyName.Name, Path.ChangeExtension(assemblyName.Name, "dll")); var typeBuilder = moduleBuilder.DefineType(name, TypeAttributes.Public, typeof(ValueType)); // Генерируем конструктор по умолчанию var constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] < >); var ilGenerator = constructorBuilder.GetILGenerator(); // Вызываем метод Console.WriteLine с указанным параметром ilGenerator.EmitWriteLine(outputString); ilGenerator.Emit(OpCodes.Ret); //assemblyBuilder.Save(); // "Закрываем" сгенерированный тип и возвращаем результат return typeBuilder.CreateType(); >

Метод GenerateValueTypeWithDefaultConstructor принимает имя типа и строку, выводимую на консоль (строка нужна для написания модульного теста, проверяющего работу этого метода). После этого, мы генерируем простой значимый тип с конструктором, вызывающим Console.WriteLine с указанной строкой.
После этого мы можем создать данный тип с помощью Activator.CreateInstance или же сохранить сгенерированную сборку с помощью AssemblyBuilder.Save и использовать ее обычным образом. После этого, можно будет пользоваться сгенерированным типом обычным образом и спокойно вызвать конструктор по умолчанию значимого типа:

// Генерируем тип и создаем экземпляр с помощью Activtor.CreateInstance var type = CustomStructEmitter .GenerateValueTypeWithDefaultConstructor("CustomValueType"); var cvt1 = Activator.CreateInstance(type); // Или создаем его обычным образом var cvt2 = new CustomValueType();

Правила вызова конструктора по умолчанию

Существует несколько моментов использования из языка C# структур с настоящим конструктором по умолчанию.

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

var array = new CustomValueType[5];

Для создания массива используется инструкция newarr, при этом происходит инициализация всех элементов массива значениями по умолчанию, что в случае значимых типов означает «обнуление» всех полей всех экземпляров массива. Даже если используемый тип содержит настоящий конструктор по умолчанию (как в нашем случае), в интересах производительности они все равно вызваны не будут.

Для вызова конструктора всех элементов нужно сделать это явно:

// Приведет к вызову конструкторов всех экземпляров массива array.Initialize();

Но даже если бы разработчики CLR и языков платформы .NET пошли бы на падение производительности за счет вызова десятков кастомных конструкторов, то это не избавило бы от всех проблем.
Давайте рассмотрим следующий код:

var list = new List(50);

Данный конструктор принимает емкость (capacity) списка, а значит внутри него будет создан массив соответствующего размера, что, в свою очередь, приведет к вызову не менее 50 конструкторов по умолчанию, хотя текущий размер списка все равно будет равным 0. Для решения этой проблемы пришлось бы разделить процесс выделения памяти для массива от процесса создания экземпляра значимого типа внутри него. Такая техника применяется в языке С++ с помощью размещающего оператора new, однако это явно добавило бы больше проблем, нежели пользы, поэтому достаточно разумно, что разработчики .NET на это не пошли.

ПРИМЕЧАНИЕ
На платформе .NET проблема со списками, массивами и перечислениями все еще существует. Подробности можно прочитать в статье «Проблемы передачи списка перечислений или Почему абстракции текут».

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

// Вызывается var cvt = new CustomValueType(); // Вызывается var cvt = Activator.CreateInstance(typeof(CustomValueType)); // Не вызывется var cvt = default(CustomValueType); static T CreateAsDefault() < return default(T); >// Не вызывается CustomValueType cvt = CreateAsDefault(); static T CreateWithNew() where T : new() < return new T(); >// Не вызывается!! CustomValueType cvt = CreateWithNew(); // Не вызывается var array = new CustomValueType[5];

Хочу обратить внимание на рассогласованность поведения в следующем случае: известно, что создания экземпляра обобщенного (generic) параметра происходит с помощью Activator.CreateInstance, именно поэтому при возникновении исключения в конструкторе пользователь обобщенного метода получит его не в чистом виде, а в виде TargetInvocationException. Однако при создании экземпляра типа CustomValueType с помощью Activator.CreateInstance наш конструктор по умолчанию будет вызван, а при вызове метода CreateWithNew и создания экземпляра значимого типа с помощью new T() – нет.

Заключение

Конструктором по умолчанию в языке C# называется инструкция обнуления значения объекта.
С точки зрения CLR конструкторы по умолчанию существуют и язык C# даже умеет их вызывать.
Язык C# не позволяет создавать пользовательские конструкторы по умолчанию для структур, поскольку это привело бы к падению производительности при работе с массивами и существенной путанице.
Работая на языках, поддерживающих создание конструкторов по умолчанию, их объявлять все равно не стоит по тем же причинам, по которым они запрещены в большинстве языков платформы .NET.
Значимые типы не так просты как кажется: помимо проблем с изменяемостью (мутабельностью) у значимых типов даже с конструкторами по умолчанию и то не все просто.