С++ для начинающих. Специальные функции-члены классов. Правило трёх
В этой статье будут описаны не очевидные на первый взгляд, но очень важные моменты, относящиеся к проектированию классов в С++. Для описания будет использовано написание примера, где класс будет представлять собой описание простенькой строки. Основу, взятую для примера, вы, возможно, сможете написать сами: нужно просто обернуть обычную Си-строку классом.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
//Листинг #0 Пример-основа к статье Оборачивание Си-строки классом clang #include <iostream> #include <cstring> //strcpy, strlen using std::cout; using std::ostream; class MyString{ unsigned len; //длина строки char* str; //указатеьная переменная в качестве строки public: static unsigned str_count; //необязательный для класса, но полезный для описания элемент: количество объектов класса MyString(); //прототип конструктора по умолчанию MyString(const char* S); //прототип конвертирующего конструктора (конструктора с одним параметром) ~MyString(); //прототип деструктора friend ostream& operator << (ostream& os, const MyString& S); //перегрузка << для (cout << S) }; unsigned MyString::str_count = 0; //инициализировали счётчик объектов нулём /* реализация конструктора по умолчанию */ MyString::MyString(){ len = 4; str = new char[len]; strcpy(str, "C++"); //по умолчанию создаём строку "С++" str_count++; //наращиваем счётчик объектов } /* реализация конструктора с параметром */ MyString::MyString(const char* S){ len = strlen(S); str = new char[len + 1]; //+1 нужен для нуль-символа, признака конца строки strcpy(str, S); //создаём строку на основании значения параметра str[len] = '\0'; //на всякий случай, если строка будет слишком большой, насильно перепишем последний символ, если вдруг конца в строке не окажется str_count++; //наращиваем счётчик объектов } MyString:: ~MyString(){ delete []str; str_count--; //с каждым разрушенным объектом счётчик объектов уменьшается } ostream& operator << (ostream& os, const MyString& S){ return os << S.str; } int main(){ MyString S1 = "Hello"; MyString S2; cout << "S1 == " << S1 << '\n'; cout << "S2 == " << S2 << '\n'; cout << "count strings == " << MyString::str_count << '\n'; } |
Для дальнейшего изучения темы вы должны понимать показанный пример. Потому что дальше происходит развитие этого примера и неочевидные на первый взгляд вещи становятся более явными.
Статический объект в классе, представляющем из себя строку, создавать необязательно и даже не нужно. Но этот элемент будет нам полезен для описания темы. Статические объекты класса по сути не являются объектами класса, а являются глобальными объектами, сокрытыми областью видимости класса. На все объекты класса, независимо от их количества, статические объекты приходятся в единственном экземпляре. В отличие от обычных элементов класса, статическую переменную, сокрытую областью видимости класса, надо инициализировать вне класса в глобальной области: где инициализируются глобальные переменные. Как это делается вы можете увидеть по коду. Просто нужно запомнить, что статические элементы класса к элементам класса не относятся, а являются глобальными элементами, внутри класса их можно только объявить, а потом обязательно инициализировать вне класса.
Добавим немного отладочной информации в виде выводов на экран информационных сообщений.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 |
//Листинг #1 Написание своего класса string clang #include <iostream> #include <cstring> //strcpy, strlen using std::cout; using std::ostream; class MyString{ unsigned len; //длина строки char* str; //указатеьная переменная в качестве строки public: static unsigned str_count; //необязательный для класса, но полезный для описания элемент: количество объектов класса MyString(); //прототип конструктора по умолчанию MyString(const char* S); //прототип конвертирующего конструктора (конструктора с одним параметром) ~MyString(); //прототип деструктора friend ostream& operator << (ostream& os, const MyString& S); //перегрузка << для (cout << S) }; unsigned MyString::str_count = 0; //инициализировали счётчик объектов нулём /* реализация конструктора по умолчанию */ MyString::MyString(){ len = 4; str = new char[len]; strcpy(str, "C++"); //по умолчанию создаём строку "С++" str_count++; //наращиваем счётчик объектов cout << str_count << " == " << str << " default object created\n"; } /* реализация конструктора с параметром */ MyString::MyString(const char* S){ len = strlen(S); str = new char[len + 1]; //+1 нужен для нуль-символа, признака конца строки strcpy(str, S); //создаём строку на основании значения параметра str[len] = '\0'; //на всякий случай, если строка будет слишком большой, насильно перепишем последний символ, если вдруг конца в строке не окажется str_count++; //наращиваем счётчик объектов cout << str_count << " == " << str << " object created\n"; } MyString:: ~MyString(){ cout << str << " object deleted\n"; delete []str; str_count--; //с каждым разрушенным объектом счётчик объектов уменьшается cout << str_count << " left\n"; //осталось объектов столько-то } ostream& operator << (ostream& os, const MyString& S){ return os << S.str; } int main(){ { MyString S1 = "Hello"; MyString S2; cout << "S1 == " << S1 << '\n'; cout << "S2 == " << S2 << '\n'; cout << "count strings == " << MyString::str_count << '\n'; } } |
Листинг #1 тот же, что и #0, просто добавились сообщения, выводимые на экран, которые могут стать полезными при дальнейшем разборе. Поскольку мы забегаем немного вперёд и знаем, к чему идём, то заранее подготовили эти сообщения.
При запуске и компиляции программы проблем никаких нет и программа работает обычным образом. Каждый конструктор содержит выражение str_count++;. Это значит, что каждый раз, когда программа создает новый объект, общая переменная str_count увеличивается на единицу, т. е. всегда содержит общее количество объектов MyString. А деструктор содержит выражение str_count—. Таким образом, класс MyString отслеживает не только создание, но и удаление объектов, храня в переменной str_count их текущее количество.
Поскольку в качестве непосредственной строки выступает указательная переменная, но указательная переменная не умеет хранить строки, а умеет указывать на адреса памяти, во всех конструкторах следует выделять область памяти для хранения строки и связывать эту область с указательной переменной. Выделяемой области памяти должно хватать для хранния строки. Внутри объекта хранится только указательная переменная, а выделяемые области памяти, с которыми связывается та указательная переменная, хранятся вне класса. Говорят, что символы строки хранятся в куче, а объект только указывает, где их искать.
Новички, которые успели поработать с указателями на строки, знают, что нельзя взять и присвоить одну строку (не являющуюся объектом класса) в другую:
|
1 2 3 4 5 6 7 8 9 10 |
//Листинг #a1 Двойное delete Неверная попытка присваивания int main() { char *ch1 = new char[255]{ "" }; char *ch2 = new char[255]{ " string " }; ch1 = ch2; delete[]ch1, delete []ch2; } |
Указательные переменные не хранят строки, поэтому попытка присвоить один указатель в другой только перенаправляет один указатель к другому. В листинге #a1 произошла привязка двух указателей к одному и тому же адресу, при этом в момент перенаправления одного ввыделенный ему участок памяти оказался потерян, это утечка памяти. Но кроме утечки памяти происходит двойное delete. А применять delete к участку памяти, который не выделен персонально, нельзя, может случится разное: поведение программы непрогнозируемо. Так вот, новички, которые успели поработать с си-строками и указателями на строки, сталкивались с этой проблемой и должны знать, что для копирования строк нужно не перенаправлять указательные переменные, а копировать строки путём копирования символов из одной выделенной области памяти в другую. Поэтому в конструкторах используются функции копирования строк.
В деструкторе происходит процесс очистки выделенных участков памяти. Независимо от того, посредством какого конструктора объект создавался, деструктор всегда будет вызываться один и тот же. Деструктор автоматически срабатывает при уничтожении объекта. Очень важно подчищать выделенную, но уже ненужную память. В деструкторе описывается реализация такой чистки.
- Всякий раз, когда в конструкторе для выделения памяти используется операция new, в соответствующем деструкторе необходима операция delete для освобождения этой памяти. Если использовалась операция new [ ] (с квадратными скобками), то нужно применять операцию delete [ ] (тоже с квадратными скобками).
Результат работы программы: 
По первым двум строчкам (см. картинку) можно судить о сработавших конструкторах и созданных строках: "Hello" создана с помощью конструктора с параметром; "C++" создана с помощью конструктора по умолчанию. Следующие две строки просто вывод значений строк на экран. А последние четыре дают нам знать, какая строка была разрушена деструктором и сколько объектов осталось.
Надеюсь, основная часть показанного примера и данные пояснения дают вам понимание происходящего, потому что теперь мы немного разовьём класс. Листинг, который будет сейчас написан, содержит в себе несколько нарочных дефектов, поэтому не нужно паниковать. Это так нужно для дальнейших объяснений. Результат работы программы неопределён и зависит от компиляторов.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 |
//Листинг #2 Написание класса строка Листинг с дефектами //добавим две функции, в которых объект класса будет выступать в роли параметра. В одном случае как параметр ссыочного характер, в другом как параметр по значению (функции callme1, callme2) #include <iostream> #include <cstring> //strcpy, strlen using std::cout; using std::ostream; using std::endl; class MyString{ unsigned len; //длина строки char* str; //указатеьная переменная в качестве строки public: static unsigned str_count; //необязательный для класса, но полезный для описания элемент: количество объектов класса MyString(); //прототип конструктора по умолчанию MyString(const char* S); //прототип конвертирующего конструктора (конструктора с одним параметром) ~MyString(); //прототип деструктора friend ostream& operator << (ostream& os, const MyString& S); //перегрузка << для (cout << S) }; unsigned MyString::str_count = 0; //инициализировали счётчик объектов нулём /* реализация конструктора по умолчанию */ MyString::MyString(){ len = 4; str = new char[len]; strcpy(str, "C++"); //по умолчанию создаём строку "С++" str_count++; //наращиваем счётчик объектов cout << str_count << " == " << str << " default object created\n"; } /* реализация конструктора с параметром */ MyString::MyString(const char* S){ len = strlen(S); str = new char[len + 1]; //+1 нужен для нуль-символа, призкака конца строки strcpy(str, S); //создаём строку на основании значения параметра str[len] = '\0'; //на всякий случай, если строка будет слишком большой, насильно перепишем последний символ, если вдруг конца в строке не окажется str_count++; //наращиваем счётчик объектов cout << str_count << " == " << str << " object created\n"; } MyString:: ~MyString(){ cout << str << " object deleted\n"; delete []str; str_count--; //с каждым разрушенным объектом счётчик объектов уменьшается cout << str_count << " left\n"; //осталось объектов столько-то } ostream& operator << (ostream& os, const MyString& S){ return os << S.str; } void callme1(MyString& S){ //параметр как ссылка cout << "reference parametr:\n" << S << '\n'; //информационное сообщение, что параметр по ссылке } void callme2(MyString S){ //параметр как ссылка cout << "value parametr:\n" << S << '\n'; //инфосообщение, что параметр по значению } int main(){ { cout << "Block start\n"; MyString S1("S1, ctor with param"); //создание объектов с помощью конструктора с параметром MyString S2("S2, ctor with param"); MyString S3("S3, ctor with param"); cout << "S1: " << S1 << endl; //вывод созданных строк на экран cout << "S2: " << S2 << endl; cout << "S3: " << S3 << endl; callme1(S1); //вызов функции с параметром-ссылкой cout << "S1: " << S1 << endl; callme2(S2); //вызов функции с параметром-значением cout << "S2: " << S2 << endl; cout << "Initialize one object to another:\n"; MyString S4 = S3; //используем конвертирующий конструктор для инициализации объекта объектом cout << "S4: " << S4 << endl; cout << "Assign one object to another:\n"; MyString S5; S5 = S1; //присваивание объекта в объект cout << "S5: " << S5 << endl; cout << "Exiting the block.\n"; } cout << "End of main()\n"; } |
Результат работы программы: 
Как было оговорено заранее, в вашем случае вывод на экран может быть иным. Я показываю ориентируясь на свой и постарался объяснить на картинке что к чему.
На моей картинке результата работы программы видно, что при срабатывании callme2(const MyString) зачем-то вызывается деструктор, но нет информации о создании объекта. Кроме того, можно наблюдать факт удаления, ибо об этом свидетельствует информационное сообщение. При срабатывании S5 = S1 зачем-то сработал конструктор по умолчанию, что можно понять по выводимому тексту. И заканчивается всё неудачей при выполнении деструкторов. Это может свидетельствовать о том, что деструкторы чистят уже почищенную память, достаточно распространённая ошибка.
Почему программа так работает? Точнее, почему она не работает? Дело в том, что С++ генерирует некоторые элементы класса неявно. Независимо от того, что получилось у вас на экране, а проблем может выползти значительно больше, чем выползло у меня, основные проблемы и способы их решения одинаковые для всех нас.
Количество вызовов конструкторов должно равнятья количеству вызовов деструкторов, но есть вероятность, что общее число объектов у вас ушло в минус.
Проблемы с классом MyString возникают из-за специальных функций-членов, которые определяются автоматически.
C++ автоматически предоставляет следующие функции-члены:
- конструктор по умолчанию, если не было определено ни одного конструктора;
- деструктор по умолчанию, если он не был определен;
- конструктор копирования, если он не был определен; (если программа использует объект так, что это определение будет нужно)
- операция присваивания, если она не была определена; (если программа использует объект так, что это определение будет нужно)
- операция взятия адреса, если она не была определена; (если программа использует объект так, что это определение будет нужно)
Например, если где-то выполняется присваивание одного объекта другому, то программа предоставляет определение для операции присваивания.
Причиной проблем с классом MyString являются неявный конструктор копирования и неявная операция присваивания.
Начиная со стандарта С++11 предлагаются еще две специальные функции-члена — конструктор переноса и операция присваивания с переносом.
Если для класса явно не задан вообще никакой конструктор, то компилятор генерирует конструктор по умолчанию: генерируемый компилятором конструктор по умолчанию пустой, не делает ничего.
|
1 2 3 4 5 6 7 8 |
//Листинг #a2 Конструктор по умолчанию всегда создаетя: если не создавать явно, создастся неявно class MyClass {}; //в классе не объявлено явно ни одного конструктора int main() { MyClass x; //x выглядит как обычная автоматическая переменная //состояние x неизвестно } |
Если определён хотя бы один конструктор не по умолчанию, то С++ не считает нужным генерировать конструктор по умолчанию.
|
1 2 3 4 5 6 7 8 9 10 11 |
//Листинг #a3 Конструктор по умолчанию не генерируется компилятором, если в классе хоть один конструктор class MyClass { public: MyClass(int x){} //один конструктор написан }; int main() { MyClass x; //ошибка компиляции, нет конструктора по умолчанию } |
- Если требуется создавать объекты, которые инициализируются неявно, то придется явно определить конструктор по умолчанию.
Несмотря на то, что конструктор по умолчанию не принимает аргументов, элементы объекта с помощью конструктора по умолчанию легко инициализировать значениями.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
//Листинг #a4 class MyClass { int x; public: MyClass() { x = 100; //инициализировали x значением 100 } }; int main() { MyClass x; //состояние x инициализировано неявно, явно описанным конструктором по умолчанию } |
Конструктор с параметрами может быть конструктором по умолчанию, если все его параметры имеют значения по умолчанию:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
//Листинг #a5 class MyClass { int x; public: MyClass(int value = 100) { //параметр конструктора имеет значение по умолчанию x = value; } }; int main() { MyClass x; //состояние x инициализируется неявно, с помощью явно описанного конструктора по умолчанию } |
Однако в классе может быть только один конструктор по умолчанию. То есть нельзя делать следующее:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
//Листинг #a6 class MyClass { int x; public: MyClass(int value = 100) {} //конструктор с параметром может быть конструктором по умолчанию MyClass(){} //явный конструктор по умолчанию }; int main() { MyClass x; //состояние x инициализируется неявно, с помощью явно описанного конструктора по умолчанию //неоднозначность: два конструктора по умолчанию, ошибка компиляции } |
Первый важный конструктор, конструктор по умолчанию, мы сейчас бегло просмотрели. Второй важный конструктор — конструктор копирования.
- Конструктор копирования служит для копирования некоторого объекта в создаваемый объект. Другими словами, он используется во время инициализации — в том числе при передаче функции аргументов по значению — но не во время обычного присваивания. Конструктор копирования для класса обычно имеет следующий прототип: Имя_класса(const Имя_класса &);
Конструктор копирования в качестве параметра принимает константную ссылку на объект класса. Например, конструктор копирования для класса String будет выглядеть так:
|
1 |
String(const String &); //прототип конструктора копирования для класса String |
О конструкторе копирования нужно знать два момента: когда он используется и что он делает.
Конструктор копирования вызывается всякий раз, когда создается новый объект, и для его инициализации берётся значение существующего объекта того же типа. Это происходит в нескольких ситуациях. Наиболее очевидный случай — когда новый объект явно инициализируется существующим объектом. Например, если motto является объектом String, то следующие четыре объявления вызывают конструктор копирования:
В зависимости от реализации, два объявления в середине (3-я и 4-я строчки листинга #a7) могут использовать конструктор копирования либо непосредственно для создания объектов metoo и also, либо для генерирования временных объектов, содержимое которых затем присваивается объектам metoo и also. Последний показанный вариант из листинга #a7 инициализирует анонимный объект значением motto и присваивает адрес нового объекта указателю pString.
|
1 2 3 4 5 |
//Листинг #a7 String ditto(motto); // вызывает String(const String &) String metoo = motto; // вызывает String(const String &) String also = String(motto); // вызывает String(const String &) String * pString = new String(motto); // вызывает StringBad(const StringBad &) |
В зависимости от реализации, два объявления в середине (3-я и 4-я строчки листинга #a7) могут использовать конструктор копирования либо непосредственно для создания объектов metoo и also, либо для генерирования временных объектов, содержимое которых затем присваивается объектам metoo и also. Последний показанный вариант из листинга #a7 инициализирует анонимный объект значением motto и присваивает адрес нового объекта указателю pString.
Менее очевидно то, что компилятор использует конструктор копирования при каждом генерировании копии объекта в программе. В частности, он применяется, когда функция передает объект по значению (как это делает функция callme2 () (в листинге #2) или когда функция возвращает объект. Ведь передача по значению подразумевает создание копии исходной переменной. Компилятор также использует конструктор копирования при генерировании временных объектов. Например, компилятор может генерировать временный объект Vector для хранения промежуточного результата при сложении трех объектов Vector. Различные компиляторы могут вести себя по-разному при создании временных объектов, но все они вызывают конструктор копирования при передаче объектов по значению и при их возврате. В частности, следующий вызов функции в однострочном листинге #2 запускает и конструктор копирования:
|
1 |
callme2(S2); |
В программе конструктор копирования применяется для инициализации S — формального параметра типа MyString для функции callme2 () (смотрите функцию callme2() и её параметры). Тот факт, что при передаче объекта по значению вызывается конструктор копирования, является хорошей причиной для передачи по ссылке. Это позволит сэкономить время вызова конструктора и память для хранения нового объекта.
Конструктор копирования по умолчанию выполняет почленное копирование нестатических членов, также иногда называемое поверхностным копированием. Каждый член копируется по значению. Если член сам является объектом класса, для копирования одного объекта-члена в другой используется конструктор копирования этого класса. Но это не влияет на статические члены, подобные str_count, поскольку они для класса вообще, а не к отдельным его объектам. Поверхностное копирование обозначает, например, что при коприовании указателей будут копироваться только адреса, но целые области памяти.
- Если в классе имеются статические данные-члены, значение которых изменяется при создании новых объектов, должен быть предусмотрен явный конструктор копирования, который принимает это внимание.
В моём случае неточности с подсчётом не возникло, но у вас это вполне может произойти. Конструктор копирования ведь в листинге #2 не написан явно, а значит есть вероятность, что при вызове функции с параметром-значением наш статический счётчик собьётся: сработает неявно сгенерированный компилятором конструктор копирования, создастся новый объект, статический счётчик никак не обновит своё значение. Приблизительно вот такого вполне можно ожидать.
Кроме потенциальной угрозы, связанной с неучитываемостью неявным конструктором копирования, более серьёзная опасность состоит в том, что если посредством конструктора копирования будет создан новый объект, то из-за указательных переменных неявным конструктором копирования указательные переменные будут перенаправляться, но не будут копироваться конечные (нужные нам) области памяти. Это значит, что можно столкнутся с поведением программы как в листинге #a8:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
//Листинг #a8 #include <iostream> using std::cout; using std::cin; using std::ostream; class MyClass { char *x; public: MyClass() :x(new char[50]{ "string created by ctor default" }) {} //конструктором по умолчанию выделяем память friend ostream& operator << (ostream& os, const MyClass& object) { return os << object.x; } //для cout << MyClass(const MyClass&) { //копирующий конструктор, навскидку в том же виде, в каком его генерирует компилятор } }; int main() { MyClass S1; cout << "S1 == " << S1 << '\n'; cout << "worked copy ctor:\n"; //смотрим н работу копирующего конструктора MyClass S2(S1); //использование копирующего конструктора для инициализации S2 состоянием S1 cout << "S2 == " << S2 << '\n'; //а память-то выделена не была, хотя S2.x был перенаправлен на S1.x //S2.x всего-лишь указатель, не связанный с большим блоком памяти cin.get(); } |
Проявится этот симптом или нет — будет зависеть от того, произойдёт ли срабатывание (инициация) конструктора копирования. И если вы явно не описывали конструктор копирования в классе, которым учили бы классы копироваться должным образом, то можете ждать бомбы замедленного действия.
Можно столкнуться с проблемой двойного delete, которой поспособствует опять же таки конструктор копирования. Чтобы на это посмотреть, достаточно немного изменить листинг #a8:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
//Листинг #a9 #include <iostream> using std::cout; using std::cin; using std::ostream; class MyClass { char *x; public: MyClass() :x(new char[50]{ "string created by ctor default" }) {} //конструктором по умолчанию выделяем память friend ostream& operator << (ostream& os, const MyClass& object) { return os << object.x; } //для cout << MyClass(const MyClass& S) { //копирующий конструктор, в том же виде, в каком его генерирует компилятор } ~MyClass(){ delete[]x; } }; MyClass foo(MyClass object) { //функция принимает объекты по значению return MyClass(object); //используем конструктор копирования для инициализации возвращаемого значения } int main() { MyClass S1, S2; S2 = foo(S1); //Двойное delete [] } |
В листинге #a9 указатели обоих объектов сводятся на один адрес памяти. Для каждого объекта вызывается деструктор. И оба деструктора выполняют delete [ ] к тому адресу, на который направлены оба указателя. Когда срабатывает конструктор копирования, сгенерированный компилятором, такую ситуацию очень легко получить при работе наших программ.
- Поведение программы при двойном delete неопределено.
Кроме описанных симптомов могут быть и другие, причиной которым может быть неявно сгенерированный конструктор копирования. Лечение — явно описывать конструктор копирования, в котором показывать компилятору как нужно копировать классы.
- Если класс содержит члены, которые являются указателями, инициализированными операцией new, потребуется определить конструктор копирования, копирующий данные, на которые указывают указатели, а не сами указатели. Это называется глубоким копированием. Альтернативная форма копирования (почленное или поверхностное копирование) просто копирует значения указателей. Поверхностная копия — это только "наружное соскабливание" информации указателя для копирования, а не "глубокая добыча", требующая копироварования конструкций, на которые указывают указатели.
Кроме проблем, возникающих из-за генерации неявным образом описанных конструкторов, проблемной может стать и операция присваивания. Объекты одного и того же класса можно присваивать друг в друга без дополнительного обучения этому класса.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
//Листинг #a10 class MyClass { }; int main() { MyClass T1, T2; T1 = T2; //объекты легко присваиваются T2 = T1; } |
Делается это благодаря неявному генерированию компилятором операции =. Операция присваивания, сгенерированная классом, принимает ссылку на объект, состояние которого предполагается скопировать, и возвращает ссылку. Это выглядит приблизительно так:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
//Листинг #a11 class MyClass { int x; char* ch; public: const MyClass & MyClass::operator=(const MyClass &object) { /*копируются элементы*/ x = object.x; ch = object.ch; /*возвращается ссылка на самого себя, но по состоянию уже обновлённого себя*/ return *this; } }; int main() { MyClass T1, T2; T1 = T2; //объекты легко присваиваются T2 = T1; } |
-
Перегруженная операция присваивания используется при присваивании одного объекта другому существующему объекту
12MyString S1,S2; //объявления, либо создание объектовS1 = S2; //присваивание
-
При инициализации объекта операция присваивания не обязательна:
12MyString S1 = S2; // используется конструктор копирования,//но возможно и присваивание
Операция присваивания — это механизм обычного копирования. Проблемы могут возникнуть такие же, какие могут возникнуть из-за неявно генерируемого компилятором конструктора копирования. Т. е. генерируемая компилятором операция присваивания выполняет поверхностное копирование, а не глубокое. В том числе копирование на статические элементы класса операцией неявного присваивания не распространяется. Нужно предотвращать возможную угрозу путём явного описания оперции присваивания, как и в случае с конструктором копирования.
Несмотря на то, что операция присваивания и конструктор копирования выполняют схожую работу, операция присваивания описывается немного иначе, чем конструктор копирования. Подробнее в статье Перегрузка операции присваивания.
Начиная с С++11 есть ещё два генерируемыех компилятором механизма. В настоящей статье не расматриваются, но уже упоминалось: конструктор перемещения и операция присваивания с переносом. Как и в случае с вышеописанными проблемами, неявная генерация и этих двух функций-членов может повлечь за собой возникновение тех же самых дефектов, которые получаются от неявной генерации компилятором упомянутых специальных функций-членов класса. Это значит, что если вы используете С++11 и старше, то должны явно описывать и эти две функции вкупе с тремя первыми.
-
Правило трёх (также известное как "Закон Большой Тройки" или "Большая Тройка") — правило в C++, гласящее, что если класс или структура определяет один из следующих методов, то они должны явным образом определить все три метода:
- Деструктор
- Конструктор копирования
- Операция присваивания копированием
Это обозначает, что в случае явного определения любого из этих трёх методов, вы на уровне автоматизма должны явно прописать два оставшихся. С С++11 действует правило пяти, но суть та же самая. Почему это необходимо, вам должно быть уже понятно: чтобы избегать таких проблем, которые были проявлены в ходе изучения этой статьи, и некоторых других, которые, возможно, пока ещё не дали о себе знать.
- Эти три метода являются особыми членами-функциями, автоматически создаваемыми компилятором в случае отсутствия их явного объявления программистом. Если один из них должен быть определен программистом, то это означает, что версия, сгенерированная компилятором, не удовлетворяет потребностям класса в одном случае и, вероятно, не удовлетворит в остальных случаях. Смотрите: Правило трёх (С++)
Теперь мы здорово осведомлены, возможно, поняли источник неприятностей и готовы обновить наш код, зная что нам нужно описать явно те функции, которые компилятор неявно загенерировал. Исправляем: деструктор написан, а копирующий конструктор и операция присваивания не написаны, значит последние две нужно написать явным образом:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 |
//Листинг #3 Леченеие проблем путём применения правила трёх Написание своего класса, представляющего из себя строку clang #include <iostream> #include <cstring> //strcpy, strlen using std::cout; using std::ostream; using std::endl; class MyString{ unsigned len; //длина строки char* str; //указатеьная переменная в качестве строки public: static unsigned str_count; //необязательный для класса, но полезный для описания элемент: количество объектов класса MyString(); //прототип конструктора по умолчанию MyString(const char* S); //прототип конвертирующего конструктора (конструктора с одним параметром) friend ostream& operator << (ostream& os, const MyString& S); //перегрузка << для (cout << S) /*ЯВНО ОПИСЫВАЕМ ВСЕ ТРИ НЕОБХОДИМЫЕ ФУНКЦИИ, КОТОРЫЕ ДО ЭТОГО ГЕНЕРИРОВАЛИСЬ КОМПИЛЯТОРОМ*/ MyString(const MyString&); //прототип конструктора копии const MyString& operator= (const MyString&); //прототип перегрузки операции присваивания ~MyString(); //прототип деструктора }; unsigned MyString::str_count = 0; //инициализировали счётчик объектов нулём /* реализация конструктора по умолчанию */ MyString::MyString(){ len = 4; str = new char[len]; strcpy(str, "C++"); //по умолчанию создаём строку "С++" str_count++; //наращиваем счётчик объектов cout << str_count << " == " << str << " default object created\n"; } /* реализация конструктора с параметром */ MyString::MyString(const char* S){ len = strlen(S); str = new char[len + 1]; //+1 нужен для нуль-символа, призкака конца строки strcpy(str, S); //создаём строку на основании значения параметра str[len] = '\0'; //на всякий случай, если строка будет слишком большой, насильно перепишем последний символ, если вдруг конца в строке не окажется str_count++; //наращиваем счётчик объектов cout << str_count << " == " << str << " object created\n"; } MyString:: ~MyString(){ cout << str << " object deleted\n"; delete []str; str_count--; //с каждым разрушенным объектом счётчик объектов уменьшается cout << str_count << " left\n"; //осталось объектов столько-то } ostream& operator << (ostream& os, const MyString& S){ return os << S.str; } /* РЕАЛИЗАЦИЯ КОНСТРУКТОРА КОПИРОВАНИЯ */ MyString::MyString(const MyString& object){ len = object.len; //скопировали длину строки из вошедшего в параметр конструктора ззначения str = new char[len + 1]; //в каждом конструкторе нужно выделять памяти, чтобы хватило на строку strcpy(str, object.str); //копируем в выделенную область памяти значения из другой области памяти str_count++; //не забываем, что сейчас мы ведём учёт объектов, в кждом конструкторе надо учитывать } const MyString& MyString::operator=(const MyString& object){ if (this == &object) return *this; //проверка на присваивание самому себе себя //полное копирование состояния копируемого объекта в текущий объект len = object.len; strcpy(str, object.str); //нужно копировать все значимые элементы (статические не имеет смысла, потому что один статический разделяется всеми объектами) return *this; //возвращаем ссылку на обновлённого самого себя } void callme1(MyString& S){ //параметр как ссылка cout << "reference parametr:\n" << S << '\n'; //информационное сообщение, что параметр по ссылке } void callme2(MyString S){ //параметр как ссылка cout << "value parametr:\n" << S << '\n'; //инфосообщение, что параметр по значению } int main(){ { cout << "Block start\n"; MyString S1("S1, ctor with param"); //создание объектов с помощью конструктора с параметром MyString S2("S2, ctor with param"); MyString S3("S3, ctor with param"); cout << "S1: " << S1 << endl; //вывод созданных строк на экран cout << "S2: " << S2 << endl; cout << "S3: " << S3 << endl; callme1(S1); //вызов функции с параметром-ссылкой cout << "S1: " << S1 << endl; callme2(S2); //вызов функции с параметром-значением cout << "S2: " << S2 << endl; cout << "Initialize one object to another:\n"; MyString S4 = S3; //используем конвертирующий конструктор для инициализации объекта объектом cout << "S4: " << S4 << endl; cout << "Assign one object to another:\n"; MyString S5; S5 = S1; //присваивание объекта в объект cout << "S5: " << S5 << endl; cout << "Exiting the block.\n"; } cout << "End of main()\n"; } |
Благодаря внесённым исправлениям программа заработала как и ожидалось в начале. Всё не так страшно и не так непонятно должно быть теперь. Специальные функции-члены, которые генерируются автоматически, не берут на себя обязательства по управлению памятью и не делают больше чем им позволено. Если какая-то из специальных функций понадобилась в классе, нужно на уровне автоматизма явно описать и остальные (по правилу большой тройки), даже если на первый взгляд кажется, что некоторые из них совсем не нужны.
Не забывайте, что если в одном конструкторе копирования выделяете указателю память, то выделять память указателю в основном правильно будет в каждом конструкторе, иначе, если в одном выделить, а в другом нет, и конструкторы сработают, то можно получить указатель без выделенной памяти, к которому произойдёт попытка доступа как к указателю, которому память выделена. Хотя и можно не выделять, но если в каких-то конструкторах память выделяется, а деструктором высвобождается, то если в каких-то отдельных память указательной переменной не выделять, то нужно направить указатель на нулевой адрес: при разрушении объекта delete, запущенное деструктором, к нулевому адресу безвредно
Если память для указательного элемента класса выделяется с помощью new, то высвобождается с помощью delete, а если new [ ], то delete [ ]. При описании деструкторов вы должны внимательно за этим следить. Это обязательное правило.
|
1 |
int *p = 0;; delete p; delete p; //к нулевому указателю безвредно |
|
1 2 3 4 5 |
//НО! int *p = 0; delete p; p = new int[0]; delete []p; //обязательно следовать если со скобками, то со скобками |
Основная цель этой статьи дать вам знать о неявной генерации компилятором некоторых функций, специальных функций-членов класса, и дать знать, что генерируемые компиляторам они могут не удовлетворять нашим потребностям в полной мере, из-за чего мы должны в некоторых ситуациях (всегда, когда пишем любую одну из них) описывать все эти функции явным образом.
Использованные материалы:
Один комментарий на «“С++ для начинающих. Специальные функции-члены классов. Правило трёх”»
Добавить комментарий
Случайная книга в электронном формате
Спасибо.
Очень полезно и доходчиво.