Scott Meyers
"Język C++ bardziej efektywny"




Scott Meyers
�Język C++ bardziej efektywny"
 
Punkt 2. Daj pierwszeństwo rzutowaniom w stylu języka C++
 
Zajmijmy się ulubionym rzutowaniem. Chociaż jest ono prawie takim samym pariasem programowania jak instrukcja goto, to jednak trwa nadal, ponieważ kiedy dochodzi do najgorszego i nie ma innego wyjścia, wtedy użycie rzutowania może się okazać ostatnią deską ratunku. W pewnych okolicznościach rzutowanie jest po prostu niezbędne.
Jednak rzutowania w stylu języka C nie są niczym przyjemnym. Po pierwsze są to raczej prymitywne bestie, które pozwalają Ci rzutować niemalże z każdego typu do dowolnego innego typu. Byłoby miło, gdyby można by1o precyzyjniej określać cel każdego rzutowania. Na przykład istnieje wielka różnica między rzutowaniem, które wskaźnik do obiektu mającego typ z modyfikatorem const zastępuje wskaźnikiem do obiektu bez modyfikatora const (tj. rzutowaniem usuwającym tylko właściwość const danego obiektu), a rzutowaniem, które wskaźnik do obiektu klasy podstawowej zastępuje wskaźnikiem do obiektu klasy pochodnej (tj. rzutowaniem całkowicie zmieniającym typ obiektu) . W tradycyjnym rzutowaniu w stylu języka C nie ma takiego rozróżnienia. (Trudno się temu dziwić - przecież rzutowanie w stylu języka C nie było przeznaczone dla C++, lecz dla C).
Drugi kłopot związany z rzutowaniami polega na tym, że niełatwo je znaleźć w programie. Pod względem syntaktycznym na rzutowanie składa się niewiele więcej niż para nawiasów oraz identyfikator, lecz identyfikatory ujęte w nawiasy występują wszędzie w programach w języku C++. Z tego powodu trudno odpowiedzieć nawet na najbardziej podstawowe pytanie: "Czy użyto jakichś rzutowań w tym programie?" Dlatego z dużym prawdopodobieństwem człowiek może podczas czytania programu nie zauważyć zastosowanych w nim rzutowań, taki zaś program jak grep nie potrafi ich odróżnić od składniowo podobnych konstrukcji, nie będących jednak rzutowaniami.
W odróżnieniu od tego skrótowego stylu zapisywania rzutowania w języku C, w języku C++ wprowadzono cztery nowe operatory rzutowania:
 
static_cast, const_cast, dynamic_cast oraz reinterpret_cast. W większości sytuacji wszystko, co trzeba wiedzieć o tych operatorach, sprowadza się do tego, że jeśli do tej pory zwykło się pisać:
 
(typ) wyrażenie
 
to teraz powinno się napisać: static_cast<typ>(wyrażenie)
 


Na przykład przypuśćmy, że chcieliśmy rzutować obiekt typu int do typu double, aby spowodować, że wartość wyrażenia typu int uzyska postać zmiennopozycyjną. Stosując rzutowanie właściwe językowi C można to tak zapisać:
int pierwszaLiczba, drugaLiczba;double wynik = ((double)pierwszaLiczba)/drugaLiczba;
 


Używając nowych operatorów rzutowania można to napisać w ten sposób:
 
double wynik = static_cast<double>(pierwszaLiczba)/drugaLiczba;
 
Teraz jest to rzutowanie, które z łatwością dostrzegą ludzie, a i programy też je rozpoznają.Operator static_cast ma zasadniczo takie samo znaczenie i moc oddziaływania jak zwykły, występujący w języku C operator rzutowania. Podlega też tego samego rodzaju ograniczeniom. Na przykład tak jak przy rzutowaniu właściwym dla języka C, również i za pomocą operatora static_cast nie można rzutować obiektu typu struct do typu int ani obiektu typu double uczynić wskaźnikiem. Co więcej, operatora static_cast nie można użyć do spowodowania tego, by typ wyrażenia pozbawić modyfikatora const, ponieważ do tego celu przeznaczono właśnie drugi nowy operator rzutowania: const_cast.Pozostałe nowe operatory rzutowania w języku C++ mają szczególne przeznaczenie. Operator const_cast służy do pozbawienia wyrażeń ich właściwości const albo volatile. Używając tego operatora, zwracasz uwagę (ludzi i kompilatorów) na fakt, że jedyną rzeczą, jaką chcesz zmienić za pomocą rzutowania, jest właściwość const bądź volatile. Kompilatory wymuszają takie znaczenie tego operatora. Jeżeli spróbujesz zastosować operator const_cast do jakichś innych celów niż pozbawienie jakiegoś wyrażenia właściwości const lub volatile, to twoje rzutowanie będzie usunięte. Oto parę przykładów.
 
class Cokolwiek { ... };class SpecjalneCokolwiek: public Cokolwiek { ... };
void uaktualnij(SpecjalneCokolwiek *wsc); const SpecjalneCokolwiek sc;
uaktualnij(&sc); // błąd, w ten sposób stałego wskaźnika












// *SpecjalneCokolwiek nie można przekazać
// do funkcji pobierającej SpecjalneCokolwiek*












uaktualnij(const_cast<SpecjalneCokolwiek*>(&wsc); // dobrze, typ stały argumentu sc jest // jawnie rzutowany (więc sc może ulec // zmianie wewnątrz funkcji uaktualnij) uaktualnij((SpecjalneCokolwiek*)&sc); // tak jak wyżej, ale przy użyciu












// trudniejszego do rozpoznania rzutowania // w stylu języka C












Cokolwiek *wc = new SpecjalneCokolwiek;
uaktualnij(wc); // błąd, wc jest typu Cokolwiek*, ale
// uaktualnij pobiera SpecjalneCokolwiek* uaktualnij(const cast<SpecjalneCokolwiek*>(wc));












// błąd, operatora const_cast można użyć tylko // w odniesieniu do typów z modyfikatorem
// const lub volatile, ale nigdy do rzutowania // w obrębie hierarchii dziedziczenia
 












Najczęstszym zastosowaniem operatora const_cast jest usuwanie właściwości const obiektu.
Drugi szczególny rodzaj rzutowania, który jest wyrażany operatorem dynamic_cast, służy do wykonywania bezpiecznego rzutowania w obrębie hierarchii dziedziczenia klas. Znaczy to, że operatora dynamic_cast używamy po to, aby wskaźniki lub odniesienia do obiektów klasy podstawowej zamienić na wskaźniki lub odniesienia do obiektów klas pochodnych lub pokrewnych, przy tym w taki sposób, który pozwala określić, czy rzutowanie się powiodło. Niepowodzenie operacji rzutowania oznacza się wskaźnikiem pustym (gdy rzutowano wskaźniki) lub sytuacją wyjątkową (gdy rzutowano odniesienia).
 
Cokolwiek *wc ;
...
uaktualnij(dynamic_cast<SpecjalneCokolwiek*>(wc));




// dobrze, do funkcji uaktualnij przekazuje wskaźnik wc do obiektu klasy




// SpecjalneCokolwiek wtedy, gdy wc rzeczywiście na niego
// wskazuje, w przeciwnym razie przekazuje wskaźnik pusty
 
Drugie, nie związane z tym zastosowanie operatora dynamic_cast polega na odnajdowaniu początku obszaru pamięci zajętego przez obiekt. Omówimy to zastosowanie w punkcie 27.
 
void uaktualnijPrzezOdniesienie(SpecjalneCokolwiek &osc);
uaktualnijPrzezOdniesienie( dynamic cast<SpecjalneCokolwiek&>(*wc));




// dobrze, do uaktualnijPrzezOdniesienie przekazuje wskaźnik wc do// obiektu klasy SpecjalneCokolwiek wtedy, gdy wc rzeczywiście na niego// wskazuje, w przeciwnym razie zgłasza sytuacja wyjątkową
 




Zastosowanie operatora dynamic_cast jest ograniczone do ułatwiania poruszania się po hierarchiach dziedziczenia klas. Nie można go używać do typów, które nie mają funkcji wirtualnych (zob. też punkt 24), ani też w celu usuwania właściwości const:
 
int pierwszaLiczba, drugaLiczba;
...
double wynik = dynamic cast<double>(pierwszaLiczba)/drugaLiczba;




// błąd, nie dotyczy dziedziczenia




const SpecjalneCokolwiek sc;
uaktualnij(dynamic cast<specjalneCokolwiek*>(&sc)); // błąd, operator dynamic cast nie usuwa właściwości const
 
Jeżeli chcesz dokonać rzutowania do typu, który nie podlega dziedziczeniu, to prawie na pewno chodzi Ci o zastosowanie operatora static_cast. Aby zaś w wyniku rzutowania usunąć właściwość const, korzystaj zawsze z operatora const_cast.Ostatnim z czterech nowych operatorów rzutowania jest operator reinterpret_cast. Służy on do wykonywania takich przekształceń typów, których wynik jest prawie zawsze zdefiniowany przez daną implementację języka C++. Z tego powodu rzutowania zaprogramowane przy użyciu tego operatora rzadko bywają przenośne.
Najczęstszym zastosowaniem operatora reinterpret_cast jest rzutowanie między typami wskaźników do funkcji. Na przykład przypuśćmy, że mamy tablicę wskaźników do funkcji konkretnego typu:
 
typedef void (*WskFun)(); // WskFun jest wskaźnikiem do funkcji, która nie pobiera










// argumentów i nie przekazuje wartościWskFun tablWskFun[10];
// tablWskFun jest tablicą 10 wskaźników WskFun
 










Przypuśćmy teraz, że chcemy (z jakichś niejasnych powodów) w tablicy tablWskFun umieścić wskaźnik do poniższej funkcji:
int wykonajByleCo();
Nie można tego zrobić bez rzutowania, ponieważ tak zadeklarowana funkcja wykonajByleCo ma inny typ niż funkcje w tablicy tablWskFun. Funkcje te przekazują wartość pustą (są typu void), funkcja wykonajByleCo przekazuje wartość typu int.
 
tablWskFun[0] = &wykonajByleCo; // błąd, niezgodność typów
 
Operator reinterpret_cast pozwala nam zmusić kompilatory, by poszły nam na rękę:
 


tablWskFun[0] = // to będzie przetłumaczone reinterpret_cast<WskFun>(&wykonajByleCo);
 


Rzutowanie wskaźników do funkcji nie jest przenośne (język C++ nie daje żadnych gwarancji na to, że wszystkie wskaźniki do funkcji będą reprezentowane w taki sam sposób), a w pewnych przypadkach takie rzutowanie daje niepoprawne wyniki (zob. punkt 31). Dlatego należy unikać rzutowania wskaźników do funkcji, chyba że jesteś w sytuacji bez wyjścia - masz nóż na gardle i to bardzo ostry nóż!
Jeżeli w Twoich kompilatorach nie ma wsparcia dla nowych operatorów rzutowania, to zamiast operatorów static_cast, const_cast lub reinterpret_cast możesz użyć zwykłego sposobu rzutowania. Co więcej, możesz zastosować makroinstrukcje, które pozwolą imitować użycie nowych sposobów rzutowania:
 


#define static_cast(TYP,WYR) (TYP)(WYR)
#define const_cast(TYP,WYR) (TYP)(WYR) #define reinterpret_cast(TYP,WYR) (TYP)(WYR)
 
Możesz z nich korzystać w następujący sposób:
 
double wynik = static_cast(double, pierwszaLiczba) / drugaLiczba;
uaktualnij(const_cast(SpecjalneCokolwiek*, &sc));
tablWskFun[0] = reinterpret_cast(WskFun, &wykonajByleCo);
 


Oczywiście takie zabiegi nie będą tak bezpieczne, jak zastosowanie właściwych operatorów, ale uproszczą Ci tworzenie nowych wersji programów wtedy, kiedy już będziesz dysponować kompilatorami, które mają wsparcie dla nowych operatorów rzutowania.
Nie ma też łatwego sposobu naśladowania zachowania operatora dynamic_cast, ale w wielu bibliotekach istnieją funkcje, które umożliwiają wykonanie bezpiecznych operacji rzutowania do klas pochodnych. Jeżeli nie masz takich funkcji, ale musisz wykonać ten rodzaj rzutowania, to możesz w tym celu powrócić do sposobu rzutowania właściwego językowi C, ale wtedy należy pożegnać się z możliwością informowania o niepowodzeniu tej operacji. Nie trzeba dodawać, że podobnie jak w powyższych przykładach - możesz zdefiniować makroinstrukcję, która będzie wyglądać tak jak dynamic_cast:#define dynamic_cast(TYP,WYR) (TYP)(WYR)Pamiętaj jednak, że nie powoduje to wykonania prawdziwej operacji dynamic_cast; nie ma sposobu stwierdzenia, że rzutowanie się nie powiodło.
Wiem, oczywiście wiem, że nowe operatory rzutowania są brzydkie i niewygodne. Jeśli ich wygląd wydaje Ci się zbyt nieprzyjemny, to pociesz się wiadomością, że rzutowanie takie jak w języku C jest nadal poprawne. Jednak to, co nowe operatory rzutowania straciły na urodzie, nadrabiają dzięki dokładnemu określeniu ich znaczenia i łatwości ich rozpoznawania. Łatwiejsze jest (zarówno dla ludzi, jak i dla narzędzi) analizowanie programów, w których użyto nowych operatorów rzutowania; ponadto kompilatory mogą w takich programach wyszukiwać błędy, które przy dawnym zapisie rzutowania pozostałyby nie zauważone. Są to poważne argumenty przemawiające za wycofaniem się ze stosowania rzutowania w stylu języka C, a można dodać do nich jeszcze jeden: otóż, być może, dobrze się stało, że operatory rzutowania wyglądają brzydko i niezbyt wygodnie pisze się je w programie.