http___fmi.wikidot.com_sdp7_1.xml
http___programmingexamples.wikidot.com_type-casting.xml
1.1 2.1 2.2 2.3 2.4 3.1 4.1 4.2 4.3 4.4 4.5 5.1 6.1 7.1 7.2 7.3 8.1 9.1 9.2 9.3 10.1 10.2 11.1 12.1 13.1 13.2 14.1 15.1 15.2 15.3 15.4 15.5 15.6 15.7 15.8 16.1 17.1 18.1 18.2 18.3 18.4
Преобразуване на типове В стандарта на C++ има четири операции за преобразуване на типовете. За предпочитане е те да се използват вместо старото преобразуване, включено в C и C++ - въпреки, че са по-малко мощни, те са по-конкретни, което дава възможност за по-точен контрол. Преобразуването в C е едно за всички случаи. Дали това е хубаво или лошо нещо, е въпрос на лично мнение. static_cast static_cast е за преобразуване на типа, когато проверката на типа се извършва по време на компилация. Извършва стандартни преобразувания. Например void* → char* и обратно. Извършването на неразрешено преобразуване е синтактична грешка. Неразрешено е преобразуването от константни в неконстантни типове, типове на указатели и псевдоними, в типове, които не са в отношение на открито наследяване, преобразуване в тип без конструктор или предефинирана операция1. Пример: #include   using std::cout; using std::endl; class BaseClass { public: void f () const { cout   (d); cout   (basePtr); derivedPtr -> f (); } извършва се понижаващо преобразуване( down cast ) на указател от базовия клас в указател на производния – което е опасно, но static_cast го позволява. Нищо не гарантира, че обектът в derivedPtr може да се използва като DerivedClass. От програмиста зависи да осигури тази гаранция. static_cast е по-несигурно, но по-бързо от dynamic_cast, защото по време на изпълнение не се проверява дали преходът е коректен. const_cast const_cast маха const или volatile чрез преобразуване. По този начин, една const стойност може да бъде използвана като обикновена, включително и да бъде променяна. Използва се когато дадена функция приема променлива от тип Т, но разполагаме с променлива от тип const T. Променлива, която е декларирана константна (const int a = 10) може да бъде променяна по този начин, но поведението не е дефинирано по стандарт. Възможно е да се изведе съобщение за грешка. Променлива, която е декларирана без const модификатор, в някой момент го е получила, а после е била взета с const_cast - може да бъде променяна без проблеми. Пример за употреба на const_cast. #include   using namespace std; void f(int* p) { cout  (b); f(c); // *b е констнанта, следващият ред не е валиден. // *b = 20; // По стандарт не е дефинирано какво ще стане тук // *c = 30; int a1 = 40; const int* b1 = &a1; int* c1 = const_cast (b1); // a1, това към което сочи c1, не е декларирана константна *c1 = 50; return 0; } reinterpret_cast reinterpret_cast се използва за нестандартни преобразувания. От един тип указател към друг. Не може да се използва за стандартни преобразувания. ( double → int ). Почти никога не се използва, защото възможностите, които предоставя са твърде непредвидими. Може да преобразува от указател към произволен клас, в указател към произволен друг. В почти всички случаи това е нещо лошо, по същите причини, поради които и със static_cast трябва да се внимава. Единствената безопасна употреба на резултата от reinterpret_cast е да се върне обратно в базовия тип. Пример: #include   using std::cout; using std::endl; void main() { int x = 120; int *ptr = &x; cout   ( ptr ) << endl; } В случая преобразува int* → char*. Може да се използва преобразуване на указател в цяло число(друг указател, short, int) и обратно. Като цяло, това е опасно. Освен всичко друго една и съща програма с reinterpred_cast може да се изпълнява различно на различни платформи.
1.1 2.1 3.1 4.1 5.1 6.1 7.1 7.2 8.1 9.1 10.1 11.1 12.1 13.1 14.1 15.1 16.1 17.1 18.1 19.1 20.1 21.1 22.1 22.2 23.1 24.1 25.1 26.1 27.1 28.1 29.1 30.1 31.1
Introduction Converting an expression of a given type into another type is known as type-casting. Implicit conversion Implicit conversions do not require any operator. Example 1: The value of a has been promoted from short to int without specifying any type-casting operator. short a = 2000; int b; b = a; Example 2: Implicit conversions also include constructor or operator conversions, which affect classes that include specific constructors or operator functions to perform conversions. In the following example, an implicit conversion happened between objects of class A and class B, because B has a constructor that takes an object of class A as parameter. class A(); class B { public: B(A a) {} }; A a; B b = a; Explicit Conversion Two ways for explicit type conversion: - Functional - c-like Example: short a = 2000; int b; b = (int) a; //c-like cast notation b = int (a); // functional notation Conversions Between Classes Four specific casting operators: - dynamic_cast   (expression) - reinterpret_cast   (expression) - static_cast   (expression) - const_cast   (expression) dynamic_cast dynamic_cast can be used to ensure that the result of the type conversion is a valid complete object of the requested class. So, dynamic_cast is always successful when we cast a class to one of its base classes. Example: class CBase { }; class CDerived: public CBase { }; CBase b; CBase* pb; CDerived d; CDerived* pd; pb = dynamic_cast (&d); // ok: derived-to-base pd = dynamic_cast (&b); // wrong: base-to-derived static_cast Example: class CBase {}; class CDerived: public CBase {}; CBase * a = new CBase; CDerived * b = static_cast (a); reinterpret_cast class A {}; class B {}; A * a = new A; B * b = reinterpret_cast (a); const_cast // const_cast #include   using namespace std; void print (char * str) { cout   (c) ); return 0; }