Шилдт c++_базовый_курс издание 3. Герберт Шилдт С базовый курс
 Скачать 9.37 Mb.
|
|
Глава 19: Динамическая идентификация типов и операторы приведения типа В этой главе рассматриваются два средства C++, которые поддерживают современное объектно-ориентированное программирование: динамическая идентификация типов (run- time type identification - RTTI) и набор дополнительных операторов приведения типа. Ни одно из этих средств не было частью оригинальной спецификации C++, но оба они были добавлены с целью усиления поддержки полиморфизма времени выполнения. Под RTTI понимается возможность проведения идентификации типа объекта во время выполнения программы. Рассматриваемые здесь операторы приведения типа предлагают программисту более безопасные способы выполнения этой операции. Как будет показано ниже, один из них, dynamic_cast, непосредственно связан с RTTI-идентификацией, поэтому операторы приведения типа и RTTI имеет смысл рассматривать в одной главе. Динамическая идентификация типов (RTTI) С динамической идентификацией типов вы, возможно, незнакомы, поскольку это средство отсутствует в таких неполиморфных языках, как С. В неполиморфных языках попросту нет необходимости в получении информации о типе во время выполнения программы, так как тип каждого объекта известен во время компиляции (т.е. еще при написании программы). Но в таких полиморфных языках, как C++, возможны ситуации, в которых тип объекта неизвестен в период компиляции, поскольку точная природа этого объекта не будет определена до тех пор, пока программа на начнет выполняться. Как вы знаете, C++ реализует полиморфизм посредством использования иерархии классов, виртуальных функций и указателей на базовые классы. Указатель на базовый класс можно использовать для ссылки на члены как этого базового класса, так и на члены любого объекта, выведенного из него. Следовательно, не всегда заранее известно, на объект какого типа будет ссылаться указатель на базовый класс в произвольный момент времени. Это выяснится только при выполнении программы — при использовании одного из средств динамической идентификации типов. Для получения типа объекта во время выполнения программы используйте оператор typeid. Чтобы получить тип объекта во время выполнения программы, используйте оператор typeid. Для этого необходимо включить в программу заголовок typeid(object) Здесь элемент object означает объект, тип которого нужно получить. Можно запрашивать не только встроенный тип, но и тип класса, созданного программистом. Оператор typeid возвращает ссылку на объект типа type_infо, который описывает тип объекта object. В классе type_info определены следующие public-члены. bool operator = (const type_info &ob); bool operator !=(const type_info &ob); bool before(const type_info &ob); const char *name(); Перегруженные операторы "==" и "!=" служат для сравнения типов. Функция before() возвращает значение true, если вызывающий объект в порядке сопоставления стоит перед объектом (элементом ob), используемым в качестве параметра. (Эта функция предназначена в основном для внутреннего использования. Возвращаемое ею значение результата не имеет ничего общего с наследованием или иерархией классов.) Функция name() возвращает указатель на имя типа. Рассмотрим простой пример использования оператора typeid. // Пример использования оператора typeid. #include #include using namespace std; class myclass { // . . . }; int main() { int i, j; float f; myclass ob; cout << "Тип переменной i: " << typeid(i).name(); cout << endl; cout << "Тип переменной f: " << typeid(f).name(); cout << endl; cout << "Тип переменной ob: " << typeid(ob).name(); cout << "\n\n"; if(typeid(i) == typeid(j)) cout << "Типы переменных i и j одинаковы.\n"; if(typeid(i) != typeid(f)) cout << "Типы переменных i и f неодинаковы.\n"; return 0; } При выполнении этой программы получены такие результаты. Тип переменной i: int Тип переменной f: float Тип переменной ob: class myclass Типы переменных i и j одинаковы. Типы переменных i и f неодинаковы. Если оператор typeid применяется к указателю на полиморфный базовый класс (вспомните: полиморфный класс — это класс, который содержит хотя бы одну виртуальную функцию), он автоматически возвращает тип реального объекта, на который тот указывает: будь то объект базового класса или объект класса, выведенного из базового. Следовательно, оператор typeid можно использовать для динамического определения типа объекта, адресуемого указателем на базовый класс. Применение этой возможности демонстрируется в следующей программе. /* Пример применения оператора typeid к иерархии полиморфных классов. */ #include #include using namespace std; class Base { virtual void f() {}; // делаем класс Base полиморфным // . . . }; class Derived1: public Base { // . . . }; class Derived2: public Base { // ... }; int main() { Base *p, baseob; Derived1 ob1; Derived2 ob2; p = &baseob; cout << "Переменная p указывает на объект типа "; cout << typeid(*p).name() << endl; p = &ob1; cout << "Переменная p указывает на объект типа "; cout << typeid(*p).name() << endl; p = &ob2; cout << "Переменная p указывает на объект типа "; cout << typeid(*p).name() << endl; return 0; } Вот как выглядят результаты выполнения этой программы: Переменная р указывает на объект типа Base Переменная р указывает на объект типа Derived1 Переменная р указывает на объект типа Derived2 Если оператор typeid применяется к указателю на базовый класс полиморфного типа, тип реально адресуемого объекта, как подтверждают эти результаты, будет определен во время выполнения программы. Во всех случаях применения оператора typeid к указателю на неполиморфную иерархию классов будет получен указатель на базовый тип, т.е. то, на что этот указатель реально указывает, определить нельзя. В качестве эксперимента превратите в комментарий виртуальную функцию f() в классе Base и посмотрите на результат. Вы увидите, что тип каждого объекта после внесения в программу этого изменения будет определен как Base, поскольку именно этот тип имеет указатель p. Поскольку оператор typeid обычно применяется к разыменованному указателю (т.е. к указателю, к которому уже применен оператор "*"), для обработки ситуации, когда этот разыменованный указатель оказывается нулевым, создано специальное исключение. В этом случае оператор typeid генерирует исключение типа bad_typeid. Ссылки на объекты иерархии полиморфных классов работают подобно указателям. Если оператор typeid применяется к ссылке на полиморфный класс, он возвращает тип объекта, на который она реально ссылается, и это может быть объект не базового, а производного типа. Описанное средство чаще всего используется при передаче объектов функциям по ссылке. Например, в следующей программе функция WhatType() объявляет ссылочный параметр на объекты типа Base. Это значит, что функции WhatType() можно передавать ссылки на объекты типа Base или ссылки на объекты любых классов, производных от Base. Оператор typeid, примененный к такому параметру, возвратит реальный тип объекта, переданного функции. /* Применение оператора typeid к ссылочному параметру. */ #include #include using namespace std; class Base { virtual void f() {}; // делаем класс Base полиморфным // . . . }; class Derived1: public Base { // . . . }; class Derived2: public Base { // . . . }; /* Демонстрируем применение оператора typeid к ссылочному параметру. */ void WhatType(Base &ob) { cout << "Параметр ob ссылается на объект типа "; cout << typeid(ob).name() << endl; } int main() { int i; Base baseob; Derived1 obi; Derived2 ob2; WhatType(baseob); WhatType(ob1); WhatType(ob2); return 0; } Эта программа генерирует такие результаты. Параметр ob ссылается на объект типа Base Параметр ob ссылается на объект типа Derived1 Параметр ob ссылается на объект типа Derived2 Существует еще одна версия применения оператора typeid, которая в качестве аргумента принимает имя типа. Формат ее таков. tуре id(имя_типа) Например, следующая инструкция совершенно допустима. cout << typeid(int).name(); Назначение этой версии оператора typeid — получить объект типа type_info (который описывает заданный тип данных), чтобы его можно было использовать в инструкции сравнения типов. Пример RTTI-приложения В следующей программе показано, насколько полезной может быть средство динамической идентификации типов (RTTI). Здесь используется модифицированная версия иерархии классов геометрических фигур из главы 15, которая вычисляет площадь круга, треугольника и прямоугольника. В данной программе определена функция fасtorу(), предназначенная для создания экземпляра круга, треугольника или прямоугольника. Эта функция возвращает указатель на созданный объект. (Функция, которая генерирует объекты, иногда называется фабрикой объектов.) Конкретный тип создаваемого объекта определяется в результате обращения к функции rand() С++-генератора случайных чисел. Таким образом, мы не можем знать заранее, объект какого типа будет сгенерирован. Программа создает десять объектов и подсчитывает количество созданных фигур каждого типа. Поскольку при вызове функции fасtorу() может быть сгенерирована фигура любого типа, для определения типа реально созданного объекта в программе используется оператор typeid. /* Демонстрация использования средства динамической идентификации типов. */ #include #include using namespace std; class figure { protected: double x, y; public: figure(double i, double j) { x = i; У = j; } virtual double area() = 0; }; class triangle : public figure { public: triangle(double i, double j) : figure(i, j) {} double area() { return x * 0.5 * y; } }; class rectangle : public figure { public: rectangle(double i, double j) : figure (i, j) {} double area() { return x * y;} }; class circle : public figure { public: circle(double i, double j=0) : figure(i, j) {} double area() {return 3.14 * x * x;} }; // Фабрика объектов класса figure. figure *factory() { switch(rand() % 3 ) { case 0: return new circle (10.0); case 1: return new triangle (10.1, 5.3); case 2: return new rectangle (4.3, 5.7); } return 0; } int main() { figure *p; // указатель на базовый класс int i; int t=0, r=0, c=0; // генерируем и подсчитываем объекты for(i=0; i<10; i++) { p = factory(); // генерируем объект cout << "Объект имеет тип " << typeid(*р).name(); cout << ". "; // учитываем этот объект if(typeid(*р) == typeid(triangle)) t++; if(typeid(*p) == typeid(rectangle)) r++; if(typeid(*p) == typeid(circle)) c++; // отображаем площадь фигуры cout << "Площадь равна " << p->area() << endl; } cout << endl; cout << "Сгенерированы такие объекты:\n"; cout << " треугольников: " << t << endl; cout << " прямоугольников: " << r << endl; cout << " кругов: " << с << endl; return 0; } Возможный результат выполнения этой программы таков. Объект имеет тип class rectangle. Площадь равна 24.51 Объект имеет тип class rectangle. Площадь равна 24.51 Объект имеет тип class triangle. Площадь равна 26.765 Объект имеет тип class triangle. Площадь равна 26.765 Объект имеет тип class rectangle. Площадь равна 24.51 Объект имеет тип class triangle. Площадь равна 26.765 Объект имеет тип class circle. Площадь равна 314 Объект имеет тип class circle. Площадь равна 314 Объект имеет тип class triangle. Площадь равна 26.765 Объект имеет тип class rectangle. Площадь равна 24.51 Сгенерированы такие объекты: треугольников: 4 прямоугольников: 4 кругов: 2 Применение оператора typeid к шаблонным классам Оператор typeid можно применить и к шаблонным классам. Тип объекта, который является экземпляром шаблонного класса, определяется частично на основании того, какие именно данные используются для его обобщенных данных при реализации объекта. Таким образом, два экземпляра одного и того же шаблонного класса, которые создаются с использованием различных данных, имеют различный тип. Рассмотрим простой пример. /* Использование оператора typeid с шаблонными классами. */ #include using namespace std; template class myclass { T a; public: myclass(T i) { a = i; } // . . . }; int main() { myclass myclass cout << "Объект o1 имеет тип "; cout << typeid(o1).name() << endl; cout << "Объект o2 имеет тип "; cout << typeid(o2).name() << endl; cout << "Объект o3 имеет тип "; cout << typeid(o3).name() << endl; cout << endl; if(typeid(o1) == typeid(o2)) cout << "Объекты o1 и o2 имеют одинаковый тип.\n"; if(typeid(o1) == typeid(o3)) cout << "Ошибка\n"; else cout << "Объекты o1 и o3 имеют разные типы.\n"; return 0; } Эта программа генерирует такие результаты. Объект o1 имеет тип class myclass Объект o2 имеет тип class myclass Объект o3 имеет тип class myclass Объекты o1 и o2 имеют одинаковый тип. Объекты o1 и o3 имеют разные типы. Как видите, несмотря на то, что два объекта являются экземплярами одного и того же шаблонного класса, если их параметризованные данные не совпадают, они не эквивалентны по типу. В этой программе объект o1 имеет тип myclass myclass Рассмотрим еще один пример применения оператора typeid к шаблонным классам, а именно модифицированную версию программы определения геометрических фигур из предыдущего раздела. На этот раз класс figure мы сделали шаблонным. // Шаблонная версия figure-иерархии. #include #include using namespace std; template class figure { protected: T x, y; public: figure(T i, T j) { x = i; у = j; } virtual T area() = 0; }; template class triangle : public figure { public: triangle(T i, T j) : figure T area() { return x * 0.5 * y; } }; template class rectangle : public figure { public: rectangle(T i, T j) : figure T area() { return x * y; } }; template class circle : public figure { public: circle(T i, T j=0) : figure T area() { return 3.14 * x * x; } }; // Фабрика объектов, генерируемых из класса figure. figure { switch(rand() % 3 ) { case 0: return new circle case 1: return new triangle case 2: return new rectangle } return 0; } int main() { figure int i; int t=0, c=0, r=0; // генерируем и подсчитываем объекты for(i=0; i<10; i++) { p = generator(); cout << "Объект имеет тип " << typeid(*p).name(); cout << ". "; // учитываем объект if(typeid(*p) == typeid(triangle if(typeid(*p) == typeid(rectangle if(typeid(*p) == typeid(circle cout << "Площадь равна " << p->area() << endl; } cout << endl; cout << "Сгенерированы такие объекты:\n"; cout << " треугольников: " << t << endl; cout << " прямоугольников: " << r << endl; cout << " кругов: " << с << endl; return 0; } Вот как выглядит возможный результат выполнения этой программы. Объект имеет тип class rectangle Объект имеет тип class rectangle Объект имеет тип class triangle Объект имеет тип class triangle Объект имеет тип class rectangle Объект имеет тип class triangle Объект имеет тип class circle Объект имеет тип class circle Объект имеет тип class triangle Объект имеет тип class rectangle Сгенерированы такие объекты: треугольников: 4 прямоугольников: 4 кругов: 2 Динамическая идентификация типов используется не в каждой программе. Но при работе с полиморфными типами это средство позволяет узнать тип объекта, обрабатываемого в любой произвольный момент времени. Операторы приведения типов В C++ определено пять операторов приведения типов. Первый оператор (он описан выше в этой книге), применяемый в обычном (традиционном) стиле, был с самого начала встроен в C++. Остальные четыре (dynamic_cast, const_cast, reinterpret_cast и static_cast) были добавлены в язык всего несколько лет назад. Эти операторы предоставляют дополнительные "рычаги управления" характером выполнения операций приведения типа. Рассмотрим каждый из них в отдельности. Оператор dynamic_cast Оператор dynamic_cast выполняет операцию приведения полиморфных типов во время выполнения программы. Возможно, самым важным из новых операторов является оператор динамического приведения типов dynamic_cast. Во время выполнения программы он проверяет обоснованность предлагаемой операции. Если в момент его вызова заданная операция оказывается недопустимой, приведение типов не производится. Общий формат применения оператора dynamic_cast таков. dynamic_cast Здесь элемент type означает новый тип, который является целью выполнения этой операции, а элемент expr— выражение, приводимое к этому новому типу. Тип type должен быть представлен указателем или ссылкой, а выражение expr должно приводиться к указателю или ссылке. Таким образом, оператор dynamic_cast можно использовать для преобразования указателя одного типа в указатель другого или ссылки одного типа в ссылку другого. Этот оператор в основном используется для динамического выполнения операций приведения типа среди полиморфных типов. Например, если даны полиморфные классы В и D, причем класс D выведен из класса В, то с помощью оператора dynamic_cast всегда можно преобразовать указатель D* в указатель В*, поскольку указатель на базовый класс всегда можно использовать для указания на объект класса, выведенного из базового. Однако оператор dynamic_cast может преобразовать указатель В* в указатель D* только в том случае, если адресуемым объектом действительно является объект класса D. И, вообще, оператор dynamic_cast будет успешно выполнен только при условии, если разрешено полиморфное приведение типов, т.е. если указатель (или ссылка), приводимый к новому типу, может указывать (или ссылаться) на объект этого нового типа или объект, выведенный из него. В противном случае, т.е. если заданную операцию приведения типов выполнить нельзя, результат действия оператора dynamic_cast оценивается как нулевой, если в этой операции участвуют указатели. (Если же попытка выполнить эту операцию оказалась неудачной при участии в ней ссылок, генерируется исключение типа bad_cast.) Рассмотрим простой пример. Предположим, что класс Base — полиморфный, а класс Derived выведен из класса Base. Base *bp, b_ob; Derived *dp, d_ob; bp = &d_ob; // Указатель на базовый класс указывает на объект класса Derived. dp = dynamic_cast if(dp) cout << "Приведение типа прошло успешно!"; Здесь приведение указателя bp (на базовый класс) к указателю dp (на производный класс) успешно выполняется, поскольку bp действительно указывает на объект класса Derived. Поэтому при выполнении этого фрагмента кода будет выведено сообщение Приведение типа прошло успешно!. Но в следующем фрагменте кода попытка совершить операцию приведения типа будет неудачной, поскольку bp в действительности указывает на объект класса Base, и неправомерно приводить указатель на базовый класс к типу указателя на производный, если адресуемый им объект не является на самом деле объектом производного класса. bp = &b_ob; /* Указатель на базовый класс ссылается на объект класса Base. */ dp = dynamic_cast if(!dp) cout << "Приведение типа выполнить не удалось"; Поскольку попытка выполнить операцию приведения типа оказалась неудачной, при выполнении этого фрагмента кода будет выведено сообщение Приведение типа выполнить не удалось. В следующей программе демонстрируются различные ситуации применения оператора dynamic_cast. // Использование оператора dynamic_cast. #include using namespace std; class Base { public: virtual void f() { cout << "В классе Base.\n"; } // . . . }; class Derived : public Base { public: void f() { cout << "В классе Derived.\n"; } }; int main() { Base *bp, b_ob; Derived *dp, d_ob; dp = dynamic_cast if(dp) { cout << "Приведение типов " <<"(из Derived * в Derived *) реализовано.\n"; dp->f(); } else cout <<"Ошибка\n"; cout << endl; bp = dynamic_cast if(bp) { cout << "Приведение типов " <<"(из Derived * в Base *) реализовано.\n"; bp->f(); } else cout << "Ошибка\n"; cout << endl; bp = dynamic_cast if(bp) { cout << "Приведение типов " <<"(из Base * в Base *) реализовано.\n"; bp->f(); } else cout << "Ошибка\n"; cout << endl; dp = dynamic_cast if(dp) cout <<"Ошибка\n"; else cout <<"Приведение типов " <<"(из Base * в Derived *) не реализовано.\n"; cout << endl; bp = &d_ob; // bp указывает на объект класса Derived dp = dynamic_cast if(dp) { cout << "Приведение bp к типу Derived *\n" << "реализовано, поскольку bp действительно\n" << "указывает на объект класса Derived.\n"; dp->f(); } else cout << "Ошибка\n"; cout << endl; bp = &b_ob; // bр указывает на объект класса Base dp = dynamic_cast if(dp) cout << "Ошибка"; else { cout <<"Теперь приведение bp к типу Derived *\n" <<"не реализовано, поскольку bp\n" <<"в действительности указывает на объект\n" <<"класса Base.\n"; } cout << endl; dp = &d_ob; // dp указывает на объект класса Derived bp = dynamic_cast if(bp) { cout <<"Приведение dp к типу Base * реализовано.\n"; bp->f(); } else cout <<"Ошибка\n"; return 0; } Программа генерирует такие результаты. Приведение типов (из Derived* в Derived*) реализовано. В классе Derived. Приведение типов (из Derived* в Base*) реализовано. В классе Derived. Приведение типов (из Base* в Base*) реализовано. В классе Base. Приведение типов (из Base* в Derived*) не реализовано. Приведение bр к типу Derived* реализовано, поскольку bр действительно указывает на объект класса Derived. В классе Derived. Теперь приведение bр к типу Derived* не реализовано, поскольку bр в действительности указывает на объект класса Base. Приведение dp к типу Base * реализовано. В классе Derived. Оператор dynamic_cast можно иногда использовать вместо оператора typeid. Например, предположим, что класс Base — полиморфный и является базовым для класса Derived, тогда при выполнении следующего фрагмента кода указателю dp будет присвоен адрес объекта, адресуемого указателем bp, но только в том случае, если этот объект действительно является объектом класса Derived. Base *bp; Derived *dp; // . . . if(typeid(*bp) == typeid(Derived)) dp = (Derived *) bp; В этом случае используется обычная операция приведения типов. Здесь это вполне безопасно, поскольку инструкция if проверяет законность операции приведения типов с помощью оператора typeid до ее реального выполнения. То же самое можно сделать более эффективно, заменив операторы typeid и инструкцию if оператором dynamic_cast: dp = dynamic_cast Поскольку оператор dynamic_cast успешно выполняется только в том случае, если объект, подвергаемый операции приведения к типу, уже является объектом либо заданного типа, либо типа, выведенного из заданного, то после завершения этой инструкции указатель dp будет содержать либо нулевое значение, либо указатель на объект типа Derived. Кроме того, поскольку оператор dynamic_cast успешно выполняется только в том случае, если заданная операция приведения типов законна, то в определенных ситуациях ее логику можно упростить. В следующей программе показано, как оператор typeid можно заменить оператором dynamic_cast. Здесь выполняется один и тот же набор операций дважды: с использованием сначала оператора typeid, а затем оператора dynamic_cast. /* Использование оператора dynamic_cast вместо оператора typeid. */ #include #include using namespace std; class Base { public: virtual void f() {} }; class Derived : public Base { public: void derivedOnly() { cout << "Это объект класса Derived.\n"; } }; int main() { Base *bp, b_ob; Derived *dp, d_ob; //-------------------------------- // Использование оператора typeid //-------------------------------- bp = &b_ob; if(typeid(*bp) == typeid(Derived)) { dp = (Derived *) bp; dp->derivedOnly(); } else cout <<"Операция приведения объекта типа Base к " <<"типу Derived не выполнилась.\n"; bp = &d_ob; if(typeid(*bp) == typeid(Derived)) { dp = (Derived *) bp; dp->derivedOnly(); } else cout <<"Ошибка, приведение типа должно " <<"быть реализовано!\n"; //-------------------------------------- // Использование оператора dynamic_cast //-------------------------------------- bp = &b_ob; dp = dynamic_cast if(dp) dp->derivedOnly(); else cout << "Операция приведения объекта типа Base к " <<" типу Derived не выполнилась.\n"; bp = &d_ob; dp = dynamic_cast if(dp) dp->derivedOnly(); else cout << "Ошибка, приведение типа должно " << "быть реализовано!\n"; return 0; } Как видите, использование оператора dynamic_cast упрощает логику, необходимую для преобразования указателя на базовый класс в указатель на производный класс. Вот как выглядят результаты выполнения этой программы. Операция приведения объекта типа Base к типу Derived не выполнилась. Это объект класса Derived. Операция приведения объекта типа Base к типу Derived не выполнилась. Это объект класса Derived. И еще. Оператор dynamic_cast можно также использовать применительно к шаблонным классам. Оператор const_cast Оператор const_cast переопределяет модификаторы const и/или volatile. Оператор const_cast используется для явного переопределения модификаторов const и/ или volatile. Новый тип должен совпадать с исходным, за исключением его атрибутов const или volatile. Чаще всего оператор const_cast используется для удаления признака постоянства (атрибута const). Его общий формат имеет следующий вид. const_cast Здесь элемент type задает новый тип операции приведения, а элемент expr означает выражение, которое приводится к новому типу. Использование оператора const_cast демонстрируется в следующей программе. // Демонстрация использования оператора const_cast. #include using namespace std; void f (const int *p) { int *v; // Переопределение const-атрибута. v = const_cast *v = 100; // теперь объект можно модифицировать } int main() { int x = 99; cout << "Значение x до вызова функции f(): " << x<< endl; f (&x); cout <<"Значение x после вызова функции f(): " << x<< endl; return 0; } Результаты выполнения этой программы таковы. Значение х до вызова функции f(): 99 Значение х после функции f(): 100 Как видите, переменная x была модифицирована функцией f(), хотя параметр, принимаемый ею, задается как const-указатель. Необходимо подчеркнуть, что использование оператора const_cast для удаления const- атрибута является потенциально опасным средством. Поэтому обращайтесь с ним очень осторожно. И еще. Удалять const-атрибут способен только оператор const_cast. Другими словами, ни dynamic_cast, ни static_cast, ни reinterpret_cast нельзя использовать для изменения const- атрибута объекта. Оператор static_cast Оператор static_cast выполняет операцию неполиморфного приведения типов. Оператор static_cast выполняет операцию неполиморфного приведения типов. Его можно использовать для любого стандартного преобразования. При этом во время работы программы никаких проверок на допустимость не выполняется. Оператор static_cast имеет следующий общий формат записи. static_cast Здесь элемент type задает новый тип операции приведения, а элемент expr означает выражение, которое приводится к этому новому типу. Оператор static_cast, по сути, является заменителем оригинального оператора приведения типов. Он лишь выполняет неполиморфное преобразование. Например, при выполнении следующей программы переменная типа float приводится к типу int. // Использование оператора static_cast. #include using namespace std; int main() { int i; float f; f = 199.22F; i = static_cast cout << i; return 0; } Оператор reinterpret_cast Оператор reinterpret_cast выполняет фундаментальное изменение типа. Оператор reinterpret_cast преобразует один тип в принципиально другой. Например, его можно использовать для преобразования указателя в целое значение и целого значения — в указатель. Его также можно использовать для приведения наследственно несовместимых типов указателей. Этот оператор имеет следующий общий формат записи. reinterpret_cast Здесь элемент type задает новый тип операции приведения, а элемент expr означает выражение, которое приводится к этому новому типу. Использование оператора reinterpret_cast демонстрируется в следующей программе. // Пример использования оператора reinterpret_cast. #include using namespace std; int main() { int i; char *p = "Это короткая строка."; i = reinterpret_cast cout << i; return 0; } Здесь оператор reinterpret_cast преобразует указатель p в целочисленное значение. Данное преобразование представляет фундаментальное изменение типа. Сравнение обычной операции приведения типов с новыми четырьмя cast- операторами Кому-то из читателей могло бы показаться, что описанные выше четыре cast-оператора полностью заменяют традиционную операцию приведения типов. И тогда у них может возникнуть такой вопрос: "Стоит ли всегда вместо обычной операции приведения типов использовать более новые средства?". Дело в том, что общего правила для всех программистов не существует. Поскольку новые операторы были созданы для повышения безопасности довольно рискованной операции приведения одного типа данных к другому, многие С++-программисты убеждены, что их следует использовать исключительно с этой целью. И здесь трудно что-либо возразить. Другие же программисты считают, что поскольку традиционная операция приведения типов служила им "верой и правдой" в течение многих лет, то от нее не стоит так легко отказываться. Например, для выполнения простых и относительно безопасных операций приведения типов (как те, что требуются при вызове функций ввода-вывода read() и write(), описанных в предыдущей главе) "старое доброе" средство вполне приемлемо. Существует еще одна точка зрения, с которой трудно не согласиться: при выполнении операций приведения полиморфных типов определенно стоит использовать оператор dynamic_cast. |