Scott Meyers "Język C++ bardziej efektywny", WNT, 1998




Scott Meyers “JÄ™zyk C++ bardziej efektywny", WNT, 1998
 
 
Punkt 6: Rozróżniaj przedrostkowe i przyrostkowe postaci operatorów zwiększania i zmniejszania
 
Dawno, dawno temu (w późnych latach osiemdziesiątych) w języku, o którym już nikt nie pamięta (w ówczesnym C++) nie można było odróżnić przedrostkowych od przyrostkowych wywołań operatorów ++ oraz --. Programiści narzekali na to zaniedbanie, więc rozszerzono język C++, zezwalając na przeciążanie obu postaci operatorów zwiększania i zmniejszania.
Powstał jednak problem składniowy, ponieważ funkcje przeciążane są rozróżniane na podstawie typu pobieranego przez nie argumentu, gdy tymczasem ani przedrostkowe, ani przyrostkowe operatory zwiększania lub zmniejszania nie pobierają argumentów. Aby przebrnąć przez te lingwistyczne wyboje postanowiono, że operatory te występujące w postaci przyrostkowej pobierają argument typu int, kiedy zaś ich funkcje są wywoływane, wtedy kompilatory milcząco przekazują 0 jako argument typu int.
 
class CND // typ liczb całkowitych o nieograniczonej dokładności
{ public:
CND& operator++(); // przedrostkowy ++
const CND operator++(int); // przyrostkowy ++
CND& operator(); // przedrostkowy

const CND operator(int); // przyrostkowy

CND& operator+=(int); // operator += dla typów CND i int
// ...
};
CND i;
++i; // wywołuje i.operator++();
i++; // wywołuje i.operator++(0);
--i; // wywołuje i.operator();
i--; // wywołuje i.operator(0);
 
Ta konwersja jest trochę dziwaczna, ale można się do niej przyzwyczaić. Ważniejszą jednak sprawą jest przyzwyczajenie się do tego, że przedrostkowe i przyrostkowe postaci tych operatorów przekazują różne typy. Mówiąc ściśle, postaci przedrostkowe przekazują odniesienie, przyrostkowe zaś
obiekt z modyfikatorem const. Zajmiemy się poniżej postaciami operatora ++, lecz to samo dotyczy obydwu postaci operatora --.
Ci programiÅ›ci, którzy używali kiedyÅ› jÄ™zyka C, mogÄ… pamiÄ™tać, że na przedrostkowÄ… postać operatora zwiÄ™kszania mówiono czasami “zwiÄ™ksz i pobierz", podczas gdy jego postać przyrostkowÄ… zwano “pobierz i zwiÄ™ksz". Te dwa zwroty warto pamiÄ™tać, ponieważ stanowiÄ… niemal formalnÄ… specyfikacjÄ™ tego, jak powinno siÄ™ implementować przedrostkowy operator zwiÄ™kszania:
 
// postać przedrostkowa: zwiększ i pobierz
CND& CND::operator++()
{ *this += 1; // zwiększ
return *this; // pobierz
}
// postać przyrostkowa: pobierz i zwiększ
const CND CND::operator++(int)
{ CND staraWartość = *this; // pobierz
++(*this); // zwiększ
return staraWartość // przekaż to, co było pobrane
}
Zauważmy, że operator w postaci przyrostkowej w ogóle nie korzysta ze swego argumentu. Jest to zachowanie typowe dla tej postaci operatora. Argument służy jedynie do odróżnienia postaci przyrostkowej od przedrostkowej w wywołaniu funkcji. Wiele kompilatorów wysyła ostrzeżenie wtedy, kiedy ktoś zaniedba użycia nazwanych argumentów w treści funkcji, której dotyczą: może to okazać się dokuczliwe. Aby uniknąć takich ostrzeżeń, stosuje się popularną strategię: opuszcza się nazwy tych argumentów, których nie zamierzamy użyć: tak właśnie postąpiono powyżej.
Jest sprawą oczywistą, dlaczego przyrostkowy operator zwiększania musi przekazać pewien obiekt (swoją poprzednią wartość), ale dlaczego typ tego obiektu musi mieć modyfikator const? Wyobraźmy sobie, że nie ma tego modyfikatora. Wówczas poprawne będą następujące instrukcje:
CND i;
i++++; // dwukrotnie użyj przyrostkowego operatora zwiększania
Jest to równoważne instrukcji:
i.operator++(0).operator++(0);
przy czym powinno być jasne, że drugie wywołanie funkcji operator++ zastosowano do obiektu przekazanego przez pierwsze jej wywołanie.
 
Nie można się z tym pogodzić z dwóch powodów. Po pierwsze jest to niezgodne z zachowaniem się typów wbudowanych do języka. Należy przyjąć dobrą zasadę, że kiedy określenie klasy wzbudza wątpliwości, wtedy trzeba tak postępować, jak w przypadku typu int, niewątpliwie zaś obiekty tego typu nie zezwalają na dwukrotne zastosowanie przyrostkowej postaci operatora zwiększania:
int i;
i++++; // błąd
Drugim powodem jest fakt, że dwukrotne użycie przyrostkowego operatora zwiększania prawie nigdy nie daje tego, czego chcielibyśmy oczekiwać. Zauważyliśmy powyżej, że drugie zastosowanie funkcji operator++ w dwukrotnym jej wywołaniu zmienia wartość obiektu przekazanego przez pierwsze wywołanie, nie zaś wartość pierwotnego obiektu. Tak więc, jeżeli instrukcja
i++++;
byłaby poprawna, to wartość zmiennej i zostałaby zwiększona tylko raz. Jest to niezgodne z intuicją, a przy tym mylące (zarówno w przypadku typu int, jak klasy CND), zatem najlepiej tego zabronić.
Język C++ zabrania takiego postępowania w odniesieniu do obiektów typu int, ale każdy programista, który tworzy klasy, musi sam sobie tego zakazać. Najłatwiej tego dokonać ustalając, że typ obiektu przekazywanego przez przyrostkową operację zwiększania ma modyfikator const. Tak więc, jeżeli kompilatory przeczytają instrukcję
i++++; // równoważne instrukcji i.operator++(0).operator++(0);
to rozpoznają, że obiekt stały, przekazany przez pierwsze wywołanie funkcji operator++ ma być użyty przez ponowne wywołanie tej samej funkcji. Jednakże operator++ nie jest zadeklarowany z modyfikatorem const, więc obiekt stały, taki jaki jest przekazywany przez funkcję zwiększania przyrostkowego operator++ nie może wywołać tego operatora. Każdy, kto kiedykolwiek zastanawiał się, czy przekazywanie obiektu stałego przez funkcję ma jakiś sens, wie teraz, że bywa tak czasami, a jako przykłady można przytoczyć przyrostkowe operatory zwiększania i zmniejszania.
Zapewne każdy, kto troszczy się o wydajność programów, zmartwił się, widząc po raz pierwszy funkcję zwiększania w postaci przyrostkowej. Funkcja ta musi utworzyć obiekt tymczasowy dla swojej wartości przekazywanej, a powyższa implementacja również powoduje, że trzeba utworzyć jawny obiekt tymczasowy (staraWartość), który następnie trzeba usunąć. Funkcja zwiększania w postaci przedrostkowej nie ma takich obiektów tymczasowych. Prowadzi to do zdumiewających wniosków, że kierując się jedynie dbałością o należytą wydajność w przypadku korzystania z klasy CND, powinno się raczej używać przedrostkowego operatora zwiększania, chyba że rzeczywiście potrzebny nam efekt zastosowania przyrostkowego operatora zwiększania. Powiedzmy to wyraźnie. Kiedy działamy na obiektach typów zdefiniowanych przez użytkownika, wtedy zawsze, jeśli tylko to możliwe, powinno się używać przedrostkowego operatora zwiększania, ponieważ jest on zdecydowanie wydajniejszy.
Zwróćmy uwagę na jeszcze jedną właściwość tych dwóch postaci operatora zwiększania. Jeśli pominiemy ich wartości przekazywane, to widać, że robią one to samo: zwiększają pewną wartość. To znaczy
przypuszczalnie robią to samo. Jaką mamy gwarancję, że po jakimś czasie ich implementacje nie będą odmienne, być może w wyniku zabiegów różnych programistów? Jeżeli nie będziemy postępować zgodnie z zasadą zawartą w powyżej przytoczonym przykładzie, to nie mamy takiej gwarancji. Zasada ta głosi, że przyrostkowe operatory zwiększania i zmniejszania powinny być implementowane za pośrednictwem ich przedrostkowych odpowiedników. Trzeba zatem utrzymywać tylko wersje przedrostkowe tych operatorów, ponieważ wersje przyrostkowe automatycznie zachowają się zgodnie z tamtymi.
[...]