Пользовательские преобразования типов: приведение объекта самодельного класса
C++ по возможности проводит неявные преобразования встроенных типов. Когда переменная одного типа получает в себя значение переменной другого типа, путём присваивания, то если фигурирующие в процессе типы тесно связаны друг с другом, С++ неявно приводит тип принимаемой переменной к типу принимающей переменной:
int x = 9.33; //тип int принимающий, тип double принимаемый, тип double преобразуется к типу int
long count = 9; //тип long принимающий, тип int принимаемы, тип int неявно преобразуется к типу long
double z = 7; //тип double принимающий, тип int принимаемы, тип int неявно преобразуется к типу double
С++ распознает, что в показанном варианте фигурирующие в выражениях типы представляют собой целые числа. Поскольку С++ поддерживает встроенные правила для преобразования между встроенными типам-числами, происходят такие приведения. Многим из моих читатетелй это уже прекрасно известно.
- Для лучшего понимания рекомендуется автором ci-plus-plus-snachala.ru к прочтению:
- С++ Неявные преобразования численных типов
Если типы не совместимы или по логике или по смыслу, то такие типы неявно не преобразуются:
int *arr = 10; //принимающий тип - (указатель на int), принимаемый тип int, тип int* к типу int неявно не преобразуется
На самом деле компьютер может представлять указатель в виде целого числа, но между указателем и целым числом есть сильное смысловое различие. Как минимум, для указателя возведение в квадрат, взятие квадратного корня, логарифма и многие другие действия, применяемые к численным типам, не нужны. А те действия, которые предусмотрены, работают иначе, чем работают действия с численными типами. В таком случае мы можем говорить о тесной связи типов, и если такая тесная связь существует, то хоть неявно проводить преобразования компилятор не будет, мы можем провести явное преобразование:
int *arr = (int*)10; //явное преобразование в стиле С, int преобразуется к int* (тип числа 10 преобразуется к адресу 10)
Также, конечно, существуют ситуации, где типы никак вообще не связаны и не представляют из себя похожей сущности. Т. е. есть такие ситуации, где ни неявно, ни явно приведения типов не происходит:
// int x = "Hello"; //принимающий тип int, принимаемый тип const char*, неявно не приводится
// int x = (int)"Hello"; //принимающий тип int, принимаемый тип const char*, явно не приводится
- Если определяемый класс в достаточной мере связан с базовым типом или другим классом, преобразование одного в другой имеет смысл. В этом случае можно указать C++ как выполнять преобразование автоматически, либо, возможно, через приведение типа.
В случае преобразования некоторого типа к типу объекта нашего класса, можно использовать конвертирующий конструктор, но при этом обратное преобразование надр будет, если оно понадобится, описывать дополнительно:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
//Листинг #1 clang Преобразования class MyClass{ int x; public: MyClass(){} MyClass(int value){ //конструктор с одним параметром, конвертирующий x = value; } }; int main(){ MyClass x = 10; //Тип MyClass принимающий, тип int принимаемый, тип int неявно преобразуется к типу MyClass int i = x; //Но обратное уже не работает. Тип int принимающий, тип MyClass принимаемый, тип MyClass неявно не преобразуется к типу int int z = (int)x; //Но обратное уже не работает. Тип int принимающий, тип MyClass принимаемый, тип MyClass явно не преобразуется к типу int } |
- Конструктор C++, который принимает один аргумент, определяет преобразование типа аргумента в тип класса. Если конструктор снабжен ключевым словом explicit, он может использоваться только с явной формой преобразования, в противном случае допускается неявное преобразование. В последних версиях действующих стандартов (начиная с С++11) конвертирующий конструктор может иметь несколько параметров или не иметь параметров вообще.
О преобразовании некоторого типа к типу класса можно почитать в статье Конструктор с параметрами. Конвертирующий конструктор и ключевое слово explicit. Настоящая статья немного о другом виде преобразований. О тех преобразованиях, которые не произошли в листинге #1, хотя по чьей-нибудь логике должны были сработать, ведь иначе дискриминация типов какая-то получается. С++ позволяет разрешить такую проблему. Для того, чтобы всё это заработало, надо наш класс научить преобразовывать типы.
Чтобы научить объект класса приводится к какому-то типу, нужно использовать вот такую конструкцию:
|
1 |
operator int(); //int можно менять на другой тип |
При этом стоит следовать вот таким правилам:
- функция преобразования должна быть методом класса;
- в функции преобразования не должен быть указан возвращаемый тип;
- функция преобразования не должна иметь аргументов.
Есть понятие перегрузки операций, которое сразу могло прийти в голову при виде ключевого слова operator. В нашем случае это не перегрузка операций, а то, что будет учить наш класс приводить свои объекты к указываемому нами типу, сейчас к int. После ключевого слова operator нужно написать тип, после которого поставить формальные круглые скобки. Нужно ещё добавить тело в фигурных скобках, в нём можно описать какие-то действия и обязательно нужно вернуть значение. Возвращаемое значение должно иметь совместимый тип с типом, указанным после слова operator. Если мы учим класс приводить объект к типу int, то и возвращать из мозга класса надо тип int, что вообще-то логично. Если бы это был string, то вот так:
|
1 |
operator string(){return S; //У S тип string} |
Подводим промежуточные итоги:
- С++ умеет преобразовывать типы.
- С++ умеет преобразовывать типы неявно или явно.
- С++ даёт возможность программисту создавать собственные типы.
- С++ даёт возможность программисту описывать и использовать преобразования для созданных им типов.
- Принимаемый тип может преобразовываться к выгодному себе типу, процессом преобразования руководит принимающий тип.
- Один из способов преобразований между типами — использование конвертирующего конструктора. Такой конструктор преобразует входящий или входящие в себя типы в тип родного себе класса.
- Другой способ преобразований — использование ключевого слова operator, к которому справа подсказывается, к какому типу приводим объекты описываемого класса, и приписываем формальные круглые скобки.
Помотрим цепочки происходящих преобразований. Чтобы понимать что-то, нужно понимать о неявных приведениях хоть что-нибудь:
|
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 |
//Листинг #2 Преобразования clang #include <iostream> using std::cout; class MyClass{ int x; public: MyClass (int value):x(value){} //конструктор по умолчанию, он же сейчас конвертирующий конструктор, ибо один параметр принимает и не explicit operator int(); //задаём умение объектам класса MyClass преобразовываться к типу int }; MyClass::operator int(){ return x; } int main(){ MyClass x = 55; //использовали конвертирующий конструктор int y = x; //использовали умение класса MyClass приводить собственные его объекты к типу int cout << y << '\n'; //55 MyClass a = 77.88; //использовали конвертирующий конструктор //но параметр int принимает тип double, происходит обрезание до целого double b = a; //MyClass преобразуется к int, а потом int преобразуется к double cout << b << '\n'; //77 } |
Поскольку целые числа умеют между собой приводится неявно, в листинге #2 местами происходт целая цепь событий: приведения паравозиком. Если бы невное приведение было не разрешено, то цепочка могла бы сорваться. Но важнее сейчас, чтобы вы увидели, что то, что не работало в листинге #1 заработало в листинге #2: взаимозаменяемое присваивание целого числа и объекта нашего самодельного класса.
|
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 |
//Листинг #3 Пользовательские преобразования типов clang #include <iostream> using std::cout; class MyClass{ double x; //<=== будьте внимательны, тип изменился (и в конструкторе тоже) public: MyClass (double value):x(value){} //конструктор по умолчанию, он же сейчас конвертирующий конструктор, ибо один параметр принимает и не explicit operator int(); //задаём умение объектам класса MyClass преобразовываться к типу int operator double(); //задаём умение объектам класса MyClass преобразовываться к типу double }; MyClass::operator int(){ return x; //вернет int, потому что operator int() } MyClass::operator double(){ return x; //вернёт double, потому что operator double() } int main(){ MyClass x = 55; //использовали конвертирующий конструктор int y = x; //использовали умение класса MyClass приводить собственные его объекты к типу int cout << y << '\n'; //55 ////////////////////////////////// MyClass a = 77.88; //использовали конвертирующий конструктор //параметр double принимает тип double double b = a; //MyClass преобразуется к double, потому что в классе operator double() предпочтительнее Operator int(), ибо не требует доп. приведений cout << b << '\n'; //77.88 } |
Поскольку неявные приведения не всегда желательны, к тому же вы могли заметить, что иногда происходит целая цепочка приведений, можно запретить выполнять приведения неявно, оставив возможность только явного осуществления такого механизма. Для этих целей используют ключевое слово explicit.
Использованием ключевого слова operator можно описывать взаимодествие не только между объектами некоторых классов и встроенными типами, но и объектов некотрых классов с объектами других классов. Всё-таки объекты классов — это те же типы, только создаваемые нами:
|
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 |
//Листинг #4 Пользовательские преобразования типов clang #include <iostream> using std::cout; class A; class B; class A { public: A(){} explicit A(const B& value){} //запрещаем конвертирующий конструктор operator B(); }; class B { public: B(){} explicit B(const A& value){} //запрещаем конвертирующий конструктор operator A(); }; A::operator B(){ return B(); } B::operator A(){ return A(); } int main() { A a; B b; a = b; //использовали умение B: (---operator A()---) b = a; //использовали умение A: (---operator B()---) } |
Если мы не запретим конвертирующий конструктор в листинге #4, то вместо того, чтобы увидеть работу ключевого слова operator в качестве обучающей части класса преобразованию объектов к иному типу, мы увидим срабатывание конструктора. Это нам совсем не нужно. А кроме этого, в показанном варианте мы не можем оставить определение обучения преобразования внутри класса, возникнет синтаксическая ошибка, поэтому нам необходимо выносить определение обучения за тело класса. Это обусловлено тем, что в получившемся коде мы возвращаем временные объекты, получаемые путём явного вызова конструкторов, но классам не хватает информации, чтобы запустить сборку объектов указанными конструкторами.
|
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 |
//Листинг #5.1 Пользовательские приведения типов Запрещаем неявность приведений clang #include <iostream> using std::cout; class MyClass{ double x; //<=== будьте внимательны, тип изменился (и в конструкторе тоже) public: MyClass (double value):x(value){} //конструктор по умолчанию, он же сейчас конвертирующий конструктор, ибо один параметр принимает и не explicit explicit operator int(); //задаём умение объектам класса MyClass преобразовываться к типу int explicit operator double(); //задаём умение объектам класса MyClass преобразовываться к типу double }; MyClass::operator int(){ return x; //вернет int, потому что operator int() } MyClass::operator double(){ return x; //вернёт double, потому что operator double() } int main(){ MyClass x = 55; //использовали конвертирующий конструктор int y = x; //<---- Ошибка!!! Попытка неявного приведения, неявное приведение запрещено применённым explicit, приписанного к operator int() cout << y << '\n'; //55 ////////////////////////////////// MyClass a = 77.88; //использовали конвертирующий конструктор //параметр double принимает тип double double b = a; //<--- Ошибка!!! Попытка неявного приведения, неявное приведение запрещено применённым explicit, приписанного к operator double() cout << b << '\n'; //77.88 } |
Несмотря на то, что неявные приведения были запрещены, явные приведения остались доступной нам возможностью. А explicit можно было дописать и к конструктору, тогда присваивание бы не сработали и надо было бы писать иницализацию, например, вот так:
|
1 |
MyClass x = MyClass(55); |
Но давайте посмотрим на листинг #5.1, перепишем его, но теперь используем явные приведения:
|
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 |
//Листинг #5.2 Пользовательские приведения типов Запрещаем неявность приведений clang #include <iostream> using std::cout; class MyClass{ double x; //<=== будьте внимательны, тип изменился (и в конструкторе тоже) public: MyClass (double value):x(value){} //конструктор по умолчанию, он же сейчас конвертирующий конструктор, ибо один параметр принимает и не explicit explicit operator int(); //задаём умение объектам класса MyClass преобразовываться к типу int explicit operator double(); //задаём умение объектам класса MyClass преобразовываться к типу double }; MyClass::operator int(){ return x; //вернет int, потому что operator int() } MyClass::operator double(){ return x; //вернёт double, потому что operator double() } int main(){ MyClass x = MyClass(55); //использовали конвертирующий конструктор int y = int(x); //Использовали явное приведения, преобразуя MyClass в тип int cout << y << '\n'; //55 ////////////////////////////////// MyClass a = 77.88; //использовали конвертирующий конструктор //параметр double принимает тип double double b = double(a); //Использовали явное приведения, преобразуя MyClass в тип double cout << b << '\n'; //77.88 } |
Как можете увидеть, использование явного преобразования типов никак не мешает работе, а заодно сам процесс нам более очевиден. Таинственности никакой: всё видно, что к чему и когда преобразуется. Если вы будете применять показанные приёмы в ваших кодах, вам только надо будет научить классы правильно выводится один из другого. Этот процесс немного напоминает частичное копирование объектов: копируете нужные значения из приводимого объекта в выводимый преобразованием объект.
В завершение статьи реализуем самодельный класс наподобие string, который будет приниматься целым числом:
ВНИМАНИЕ!
- Если вы используете Visual Studio, то могут возникнуть небольшие проблемы навязчивости, язык С++ тут ни при чём. Если у вас будет происходить ругательство на strcpy, если вы не знаете как это исправить, то можете подсмотреть видео: https://youtu.be/NZW7djD3mH8
В видео показано, куда вписывать _CRT_SECURE_NO_WARNINGS
Если там что-то будет вписано, то нужно будет испольовать точку с запятой как разделитель.
Свойства проекта -> С/С++ -> Препроцессор -> Опеределения препроцессора
Возвращаемся к примерам. Изучаем код:
|
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 |
//Листинг #6.1 Visual Studio Пользовательские преобразования типов #include <iostream> #include <string.h> using std::cout; using std::ostream; class string{ char *ch; //указатель для создания строкового представления данных public: explicit string(); //конструктор без параметров, прототип explicit string(const char*); //конструктор, принимающий строку, прототип ~string(); //деструктор friend ostream& operator << (ostream&, const string&); //прототип дружественной функции operator int(); //учим приводиться к типу int, прототип }; string::string(){ ch = 0; } string::string(const char* ch_){ const size_t MAX_LEN = strlen(ch_); ch = new char[MAX_LEN + 1]; strcpy(ch, ch_); } string::~string(){ delete []ch; } ostream& operator <<(ostream& stream, const string& s){ return stream << s.ch; } /*УЧИМ КЛАСС ПРИВОДИТЬ СВОИ ОБЪЕКТЫ К ТИПУ int*/ string::operator int(){ int x = 0; //это конечное значение, которое будет отдаваться, оно должно быть int или уметь приводиться к int //цикл преобразования из строкового представления числа в число for (size_t i=0; i<strlen(ch); i++){ x*= 10; x = (x + ch[i] - '0'); } return x; //отдаем полученное вычислением значение на выход } int main(){ string S("678"); int x = S; //int умеет принимать в себя string!!! cout << x << '\n'; } |
Этот последний код не очень практичен. Да и при некотором развитии своём может запутать. Если в строку, например, присваивать напрямую числовое значение, а не строковое, то можно легко запутаться. К счастью, в данном случае присваивать в строку число напрямую нельзя, потому что строка и число по смыслу сильно отличные друг от друга типы, но у непоседливого читателя может появиться ярое желание перегрузить операцию присваивания, чтобы присваивание работало в обоих направлениях. Хоть такое и возможно, такое идеологически ошибочно. В нашем же случае могут произойти ошибки (по сути не ошибки, для нас могут выглядеть как ошибки), если мы будем отдавать на обработку строковое строку не являющуюя числом, хотя подобное будет работать, расчитать, что получится в конечном итоге будет слегка тяжеловато (особенно тем, кто плохо понимает, что происходит).
|
1 2 3 4 |
string S("Hello"); //Не число, но набор символов преобразуется в числовое представление и этот результат будет отдан в виде числа, которое и присвоится в x ниже //это происходит потому что мы так написали функцию преобразования из строки в число int x = S; cout << x << '\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 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
//Листинг #6.2 Visual Studio Пользовательские преобразования типов #include <iostream> #include <string.h> #include <cstdlib> #include <string> #include <sstream> //для относительно короткого способа перевода числа в строку using std::cout; using std::ostream; using std::stringstream; class my_string { char *ch; //указатель для создания строкового представления данных public: explicit my_string(); //конструктор без параметров, прототип explicit my_string(const char*); //конструктор, принимающий строку, прототип ~my_string(); //деструктор friend ostream& operator << (ostream&, const my_string&); //прототип дружественной функции operator int(); //учим приводиться к типу int, прототип void operator = (const int); //перегружаем операцию присваивания, чтобы принимала в себя число, прототип }; my_string::my_string() { ch = new char[255]; ch[0] = 0; } my_string::my_string(const char* ch_) { const size_t MAX_LEN = strlen(ch_); ch = new char[MAX_LEN + 2]; //конец строки, знак (положительное или отрицательное) strcpy(ch, ch_); } my_string::~my_string() { delete[]ch; } ostream& operator <<(ostream& stream, const my_string& s) { return stream << s.ch; } my_string::operator int() { int x = 0; bool negative = false; //признак отрицательности числа for (size_t i = 0; i<strlen(ch); i++) { if (ch[i] == '-') { //если число отрицательное negative = true; //обозначаем continue; //пропускам ход цикла } x *= 10; //собираем из символов число x = (x + ch[i] - '0'); } if (negative) x = -x; //если было определено, что вошло отрицательное представление числа, то возвращаем отрицательное число return x; } /*ПЕРЕГРУЗКА ОПЕРАЦИИ =*/ void my_string::operator=(const int value) { stringstream ss; //описываем перевод из числа в строку ss << value; ss >> ch; } int main() { my_string S; S = 25; //Ход конём. Сначала int переносим в объект нашего класса int x = S; //Потом в независимый int переносим объект нашего класса cout << x << '\n'; //выводим значение стороннего int system("PAUSE"); } |
На случай необходимости инициализации должен быть описан подходящий конструктор, если вдруг кого озаботит маленькое ограничение, которое, возможно, обнаружится непоседой.
Использованные материалы:
Случайная книга в электронном формате
Добавить комментарий