Перегрузка операции присваивания
Операция присваивания нам, наверное, всем хорошо известна. Обознается она как =. Эта операция требует себе двух участников: объект, в который присваивается значение, и объект, который выполняет роль присваиваемого. Следовательно, операция бинарная. Это значит, что пишется реализация перегрузки операции = по тому же принципу, какой у +, +=, * и любой другой бинарной операции.
Поскольку операция присваивания предполагает собой копирование состояний, то в реализации перегруженной функции всё сводится к банальному копированию значений. Возвращается из функции-перегрузки ссылка объекта на самого себя, т. е. *this.
Есть различные варианты реализаций операций присваивания. Поскольку мы в большинстве случаев присваиваем объекты одного и того же типа, а операция присваивания умеет генерироваться неявно, случаи без ручного управления памятью не так интересны и не дают некоторых необходимых сведений.
Когда происходит ручное правление памятью (например, используется операция new), присваивание (оно же — копирование) осложняется. Одна из сложностей (которая легко обходится простой проверкой) — присваивание объекта самому себе.
- Поскольку объект-приёмник может ссылаться на данные, для которых уже была распределена память, функция должна использовать операцию delete [ ] для её освобождения.
- Функция-перегрузки операции присваивания должна содержать защиту от присваивания объекта самому себе — иначе освобождение памяти может стереть содержимое объекта до того, как оно будет переустановлено.
- Функция-перегрузки операции присваивания возвращает ссылку на вызывающий объект.
Дл примера опишем класс, представляющий из себя очень ограниченный вариант стандартного класса std::string. Не будем делать никаких крутых вещей, но нам понадобятся знания:
Эти знания необходимы для того, чтобы использованную в статье основу, взятую в качестве примера, вы понимали.
|
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 |
//Листинг #1 Основа для дальнейшего объяснения clang #include <cstring> #include <iostream> using std::ostream; using std::cout; class MyString{ char *str; public: MyString(); //прототип конструктора по умолчанию ~MyString(); //прототип деструктора MyString(const char*); //прототип конструктора с параметром friend ostream& operator << (ostream& , const MyString&); //прототип перегрузки << }; MyString::MyString(){ str = new char[255]; str[0] = 0; //нуль-символ, имитируем пустую строку } MyString::~MyString(){ delete []str; } MyString::MyString(const char* S){ str = new char[255]; strcpy(str, S); //копируем строку извне вовнутрь класса } ostream& operator << (ostream& os, const MyString& S){ return os << S.str; } int main(){ MyString S1("Hello world"); MyString S2; cout << "S1 == " << S1 << '\n'; cout << "S2 == " << S2 << '\n'; } |
В заложенной основе нет перегруженной операции присваивания. Несмотря на это сама операция присваивания работает, но вот то как она работает, это проблема:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
//Дополняем main, проверяя операцию присваивания int main(){ MyString S1("Hello world"); MyString S2; cout << "S1 == " << S1 << '\n'; cout << "S2 == " << S2 << '\n'; S1 = S2; //несмотря на то, что это работает cout << S1 << '\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 |
//Листинг #2 Перегрузка операции присваивания clang #include <cstring> #include <iostream> using std::ostream; using std::cout; class MyString{ char *str; public: MyString(); ~MyString(); MyString(const char*); friend ostream& operator << (ostream& , const MyString&); MyString& operator = (const MyString&); //прототип перегрузки операции = }; MyString::MyString(){ str = new char[1]; str[0] = 0; } MyString::~MyString(){ delete []str; } MyString::MyString(const char* S){ str = new char[255]; strcpy(str, S); } ostream& operator << (ostream& os, const MyString& S){ return os << S.str; } /* РЕАЛИЗАЦИЯ ПЕРЕГРУЗКИ ОПЕРАЦИИ ПРИСВАИВАНИЯ */ MyString& MyString::operator=(const MyString& S){ if (this == &S) return *this; //Если попытка присвоиться в себя, то сразу выходим, отдавая ссылку на самого себя delete []str; //зачищаем строку нынешнего объекта size_t len = strlen(S.str) + 1; //узнаём длину копируемой строки, учитываем нуль-символ str = new char[len]; //выделяем память, столько же, сколько у копируемой строки strncpy(str, S.str, len); //копируем в новорожденную строку значения из присваиваемой в неё строку return *this; //отдаём назад ссылку на самого себя } int main(){ MyString S1; MyString S2("Hello world"); cout << "S1 == " << S1 << '\n'; cout << "S2 == " << S2 << '\n'; S1 = S2; //благодаря явной перегрузке операции присваивания эта строчка теперь выполняет свою работу как надо cout << "\noperation: S1 = S2" << '\n'; cout << "S1 == " << S1 << '\n'; cout << "S2 == " << S2 << '\n'; } |
В случае со строкой не нужно дополнительно учитывать длину, потому что благодаря нуль-символу всегда можно узнать актуальную длину Си-строки. Но в случае написания класса, где не будет возможности подсчёта необходимых количеств, эти количества нужно будет копировать в функции-перегрузке операции присваивания дополнительно. Чтобы не получить огрызок, нужно копировать все важные составляющие объекта: будь это количество ячеек, вместимость или что-то ещё.
Особо ничего сложного в перегрузке операции присваивания нет, только помнить нужно о возможности присваивания самого в себя и избегать это простым условием, что продемонстрировано в листинге #2.
Основу вы уже узнали, сейчас речь пойдёт о других вариантах реализации. В С++11 появился спецификатор noexcept. Этот спецификатор указывает, может ли функция вызывать исключения. Поскольку я не знаком с исключениями, то именно предполагаемый сейчас пример подробным образом объяснить не сумею. Просто оставлю на этой странице сам пример и напишу как оно называется. Есть в С++ идиома, называется copy-and-swap. Копия-и-обмен. Чтобы использовать эту идиому в коде, нужно будет дописать конструктор копирования. Внутри функции-перегрузки операции присваивания будет создан временный объект, в который благодаря копирующему конструктору будет сохранено состояние присваиваемого объекта. Кроме этого, нужно будет описать реализацию обмена. Использование идиомы даёт больше удобства относительно описанного в этой статье способа, но за удобство нужно будет платить бо́льшими ресурсозатратами.
Модифицируем листинг #2 путём использования идиомы copy-and-swap:
|
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 |
//Листинг #3 Перегрузка операции присваивания Идиома copy-and-swap C++11 clang #include <cstring> #include <iostream> using std::ostream; using std::cout; class MyString{ char *str; public: MyString(); ~MyString(); MyString(const char*); MyString(const MyString&); //прототип конструктора копирования friend ostream& operator << (ostream& , const MyString&); MyString& operator = (MyString&); //прототип перегрузки операции = void swap(MyString &) noexcept; //прототип функции swap (не бросающего исключений) }; MyString::MyString(){ str = new char[1]; str[0] = 0; } MyString::~MyString(){ delete []str; } MyString::MyString(const char* S){ str = new char[255]; strcpy(str, S); } /* РЕАЛИЗАЦИЯ КОНСТРУКТОРА КОПИРОВАНИЯ */ MyString::MyString(const MyString& S){ size_t len = strlen(S.str) + 1; str = new char[len]; strncpy(str, S.str, len); } ostream& operator << (ostream& os, const MyString& S){ return os << S.str; } /* РЕАЛИЗАЦИЯ ПЕРЕГРУЗКИ ОПЕРАЦИИ ПРИСВАИВАНИЯ */ MyString& MyString::operator=(MyString& S){ if (this == &S) return *this; //Если попытка присвоиться в себя, то сразу выходим, отдавая ссылку на самого себя MyString tmp(S); //создаём временный объект this->swap(S); //меняем местами значения временного объекта со знаениям настоящего объекта return *this; //отдаём назад ссылку на самого себя } /* РЕАЛИЗАЦИЯ ОБМЕНА ЗНАЧЕНИЙ */ void MyString::swap(MyString &S) noexcept{ std::swap(S.str, str); //меняем местами значения присваимаего объекта и объекта, в который присваивается присваиваемый объект } int main(){ MyString S1; MyString S2("Hello world"); cout << "S1 == " << S1 << '\n'; cout << "S2 == " << S2 << '\n'; MyString S3(S2); cout << "S3 == " << S3 << '\n'; } |
Есть ещё один способ реализации, ненадёжный способ. Некоторые люди могут явно вызывать деструктор и тут же создавать копию копируемого объекта в объект-приёмник. В этом варианте также используется копирующий конструктор, но не описывается функция обмена значений. Ненадёжность заключается в том, что если конструктор копирования выкинет исключение, то объект-приёмник может поломаться: получится частичноскопированный объект, из-за чего могущий стать негодным к использованию. В отличие от этого ненадёжного варианта, вариант swap-and-copy предоставляет определённые гарантии. Листинг #4 описывает ненадёжный способ реализации перегрузки операции присваивания. Совет: не использовать такой вариант.
|
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 |
//Листинг #4 Ненадёжная реализация перегрузки операции присваивания: явный вызов деструктора и применение new на перераспределение памяти + копирование #include <cstring> #include <iostream> using std::ostream; using std::cout; class MyString{ char *str; public: MyString(); ~MyString(); MyString(const char*); MyString(const MyString&); //прототип конструктора копирования friend ostream& operator << (ostream& , const MyString&); MyString& operator = (MyString&); //прототип перегрузки операции = }; MyString::MyString(){ str = new char[1]; str[0] = 0; } MyString::~MyString(){ delete []str; } MyString::MyString(const char* S){ str = new char[255]; strcpy(str, S); } /* РЕАЛИЗАЦИЯ КОНСТРУКТОРА КОПИРОВАНИЯ */ MyString::MyString(const MyString& S){ size_t len = strlen(S.str) + 1; str = new char[len]; strncpy(str, S.str, len); } ostream& operator << (ostream& os, const MyString& S){ return os << S.str; } /* РЕАЛИЗАЦИЯ ПЕРЕГРУЗКИ ОПЕРАЦИИ ПРИСВАИВАНИЯ */ MyString& MyString::operator=(MyString& S){ if (this == &S) return *this; //Если попытка присвоиться в себя, то сразу выходим, отдавая ссылку на самого себя this-> ~MyString(); //явно вызываем деструктор для настоящего объекта new (this) MyString(S); //и тут же выделяем новую память настоящему объекту и копируем в неё состояние присваиваемого объекта return *this; //отдаём назад ссылку на самого себя } int main(){ MyString S1; MyString S2("Hello world"); cout << "S1 == " << S1 << '\n'; cout << "S2 == " << S2 << '\n'; S1 = S2; cout << "\noperation: S1 = S2:\n"; cout << "S1 == " << S1 << '\n'; cout << "S2 == " << S2 << '\n'; } |
Листинг #4 продемонстрован только для того, чтобы понятно было, что имелось в виду, когда упоминалось о ненадёжном способе реализации перегрузки операции присваивания.
Есть и ещё один способ. Объяснить я его не смогу, ибо он просто списан с других страниц интернета: Перегрузка оператора присваивания C++ и слегка переделан. Но почему бы не показать, да? С++11, смотрите на здоровье, листинг #5:
|
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 |
//Листинг #5 Перегрузка операции присваивания C++11 clang #include <cstring> #include <iostream> using std::ostream; using std::cout; class MyString{ char *str; public: MyString(); ~MyString(); MyString(const char*); MyString(const MyString&); //прототип конструктора копирования friend ostream& operator << (ostream& , const MyString&); void swap(MyString& other); //прототип функции перемены мест элементов MyString(MyString&& other); //прототип конструктора переноса MyString& operator=(MyString other); //прототип функции-перегрузки операции присваивания }; MyString::MyString(){ str = new char[1]; str[0] = 0; } MyString::~MyString(){ delete []str; } MyString::MyString(const char* S){ str = new char[255]; strcpy(str, S); } /* РЕАЛИЗАЦИЯ КОНСТРУКТОРА КОПИРОВАНИЯ */ MyString::MyString(const MyString& S){ size_t len = strlen(S.str) + 1; str = new char[len]; strncpy(str, S.str, len); } ostream& operator << (ostream& os, const MyString& S){ return os << S.str; } /* РЕАЛИЗАЦИЯ ОБМЕНА ЭЛЕМЕНТАМИ */ void MyString::swap(MyString& other) { std::swap(str, other.str); } MyString::MyString(MyString&& other) // конструктор копирования из rvalue, он же конструктор переноса { this->swap(other); } /* РЕАЛИЗАЦИЯ ОПЕРАЦИИ ПРИСВАИВАНИЯ */ MyString& MyString::operator=(MyString other) { // передача параметра по значению важна! this->swap(other); // обмен с временной копией return *this; } int main(){ MyString S1; MyString S2("Hello world"); cout << "S1 == " << S1 << '\n'; cout << "S2 == " << S2 << '\n'; S1 = S2; cout << "\noperation: S1 = S2:\n"; cout << "S1 == " << S1 << '\n'; cout << "S2 == " << S2 << '\n'; } |
Случайная книга в электронном формате
Добавить комментарий