Wstecz: 10. Konwersje niejawne, porządek W górę: 10. Konwersje niejawne, porządek Dalej: 10.2 Porządek wartościowania

---

10.1 Konwersje standardowe

Rozważmy niewinnie wyglądający fragment programu:

       double x = 1.5, y;
       int    k =  10;
           // ...
       y = x + k;

Załóżmy, że w programie występuje wyrażenie z operatorem dwuargumentowym (dodawanie, mnożenie, ...). Przed wykonaniem operacji dokonywane są na wartościach argumentów konwersje standardowe, których celem jest:

• doprowadzenie do tego, aby typy argumentów były takie same;
• zapewnienie, aby ten wspólny typ był „obsługiwany” przez istniejącą funkcję realizującą działanie danego operatora;
• zachowanie, w miarę możności, precyzji wyniku.

Wyjaśnijmy przebieg poszukiwania tego wspólnego dla wartości obu argumentów typu. Zauważmy, że konwersje są, jeśli to tylko możliwe, promocjami, to znaczy typ „węższy” jest awansowany do typu „szerszego” tak, żeby nie utracić dokładności. W tym sensie np. typ int jest „węższy” od double, bo każda wartość całkowita może być zapisania w formie double bez utraty dokładności, ale nie odwrotnie. Z drugiej strony, nie dla wszystkich pokrewnych typów można zdefiniować taką relację zawierania: zbiory wartości typu int i typu unsigned int są tak samo liczne (2³² elementów), ale żaden nie zawiera się w drugim. Wrócimy do tego problemu w dalszym ciągu.

Zatem:

1. Jeśli jeden z argumentów jest long double, to drugi jest też przekształcany do typu long double (oczywiście jeśli już nie był tego typu).
2. W przeciwnym przypadku: jeśli jeden jest typu double, to drugi też jest przekształcany do typu double.
3. W przeciwnym przypadku: jeśli jeden jest typu float, to drugi też jest przekształcany do typu float.
4. W przeciwnym przypadku oba argumenty są typów całościowych i są poddawane promocji całościowej zgodnie z następującą procedurą:
   • Wartości typu signed char, unsigned char, signed short i  unsigned short są przekształcane do typu int, jeśli wartość typu int może reprezentować wszystkie wartości tych typów (co zachodzi dla „zwykłych”, 32-bitowych maszyn). W przeciwnym przypadku są przekształcane do typu unsigned int, co oczywiście może zmienić ich wartość!
   • Wartości typu wyliczeniowego są przekształcane do najwęższego z typów int, unsigned int, long, unsigned long, który jest dostatecznie obszerny, aby reprezentować wszystkie wartości wyliczenia.
   • Pola bitowe (rozdział o polach bitowych ) są przekształcane do typu int lub jeśli ten typ nie może reprezentować wszystkich wartości pola — do typu unsigned int.
   • Wartości typu bool są przekształcane do wartości 0 (false) i 1(true) typu int.
5. Następnie: Jeśli jeden z argumentów jest typu unsigned long, to drugi też jest przekształcany do typu unsigned long.
6. W przeciwnym razie: jeśli jeden z argumentów jest typu long a drugi typu unsigned int i jeśli wartości typu unsigned int można w danej implementacji reprezentować w typie long (co zwykle nie zachodzi na „zwykłych” maszynach 32-bitowych), to wartość typu unsigned int jest przkształcana do typu long; w przeciwnym razie oba argumenty są przekształcane do typu unsigned long (co może spowodować nieszczęście...).
7. W przeciwnym razie, jeśli jeden z argumentów jest typu long, to drugi jest też przekształcany do typu long.
8. W przeciwnym razie, jeśli jeden z argumentów jest typu unsigned int, to drugi jest też przekształcany do typu unsigned int.
9. W przeciwnym razie oba argumenty są typu int i żadna konwersja nie jest potrzebna.

Na przykład, zgodnie z tymi zasadami, wyrażenie w trzeciej linii fragmentu

       int i = 1, j = 2, k = 3, m;
       // ...
       m = (j > i) + (k > j);

Często popełniany jest błąd przy dzieleniu: pamiętajmy, że dzielenie liczb całkowitych zawsze, zgodnie z powyższymi zasadami, daje wynik całkowity, a więc części ułamkowej nie ma. Początkującym często wydaje się, że jeśli przypisują wynik do zmiennej typu double, to w jakiś tajemniczy sposób część ułamkowa zostanie „odzyskana”: tak nie będzie, jej tam po prostu nie ma, nie została policzona! Tak więc, jeśli aktualną wartością zmiennej k typu int jest 7, to wartością wyrażenia ' k/2' jest dokładnie 3. Jeśli chodziło nam raczej o  3, to wystarczy dopisać kropkę przy dwójce: wartością ' k/2.' jest 3.5, bo '2.' (z kropką) jest interpretowane jako literał wartości typu double, a zatem i wartość k zostanie przekształcona do typu double, a co za tym idzie i wynik będzie również tego właśnie typu.

Do standardowych niejawnych konwersji, które mogą być wykonane bez naszej wiedzy (i, niestety, zgody...), należy też:

• Przekształcenie dowolnego wskaźnika typu obiektowego do typu void*. Nie dotyczy to wskaźników do funkcji czy metod —  rozdział o wskaźnikach funkcyjnych .
• Przekształcenie wyrażenia stałego o wartości 0 (zero) do wskaźnika NULL dowolnego typu oznaczającego wskaźnik pusty — nie wskazujący na żaden obiekt. Zero jest jedyną wartością całkowitą, którą można przekształcić niejawnie na wartość wskaźnikową. Niejawne przekształcenie w drugą stronę — od wskaźnika pustego do liczby zero —  nie zachodzi.
• Przekształcenie wartości o typie T* do wartości o typie const T* i od T& do const T&, gdzie T jest pewnym typem. Niejawne przekształcenie w drugą stronę nie zachodzi.
• Przekształcenie wartości typu liczbowego (całościowego lub zmiennopozycyjnego) lub wskaźnikowego do wartości typu bool (zero → false, nie-zero → true).
• Przekształcenie wartości typu całościowego do innego typu całościowego: jeśli typ docelowy jest unsigned, to wartość docelową tworzy się przez przekopiowanie, bez żadnej interpretacji, tylu bitów, ile ma typ docelowy.
• Przekształcenie wartości typu float do double i odwrotnie!
• Przekształcenie wartości typów całościowych w zmiennoprzecinkowe i odwrotnie (te ostatnie z obcięciem części ułamkowej).
• Przekształcenie wskaźnika lub referencji do obiektu klasy pochodnej do wskaźnika lub referencji do obiektu klasy podstawowej.

Brzmi to skomplikowanie, bo też, niestety, jest to skomplikowane. W dodatku jest też niebezpieczne: w C/C++ dozwolone są niejawne konwersje, na skutek których traci się informację (zwykle kompilatory wyświetlają wtedy jakieś ostrzeżenia).

Pamiętać przy tym należy, że niejawne konwersje wcale nie gwarantują, że otrzymana po przekształceniu wartość jest z naszego punktu widzenia sensowna, to znaczy zgodna w oczekiwanym przez nas sensie z wartością przed przekształceniem. Na przykład rozpatrzmy program:

      1.  #include <iostream>
      2.  using namespace std;
      3.  
      4.  int main()
      5.  {
      6.      int      k   = -2;
      7.      unsigned uns =  1;
      8.  
      9.      int      x = k + uns;
     10.      unsigned y = k + uns;
     11.  
     12.      cout << "x   = " << x      << endl;
     13.      cout << "y   = " << y      << endl;
     14.      cout << "y+1 = " << y + 1  << endl;
     15.  
     16.  
     17.      signed   char c = 255;
     18.      unsigned char d = 255;
     19.  
     20.      cout << "c+1 = " << c + 1  << endl;
     21.      cout << "d+1 = " << d + 1  << endl;
     22.      d = d + 1;
     23.      cout << "d   = " << (int)d << endl;
     24.  }

Program ten drukuje:

    x   = -1
    y   = 4294967295
    y+1 = 0
    c+1 = 0
    d+1 = 256
    d   = 0

Najczęściej jednak nie musimy aż tak dokładnie analizować tego typu wyrażeń, jeśli trzymamy się podstawowych typów i staramy się pisać kod w sposób czytelny i prosty. Trzeba tylko pamiętać, że typy całkowite węższe od int zawsze promowane są co najmniej do typu int. Dotyczy to w szczególności wartości znakowych (typu char). Użyte jako argument operatorów lub argument w wywołaniu funkcji są przekształcane do wartości całkowitej typu int równej kodowi ASCII danego znaku. Na przykład po przypisaniu

       int k = 3 + 'a';

Można z tej własności skorzystać do napisania prostej funkcji odczytującej ciąg znaków aż do napotkania nie-cyfry i interpretującej ten napis jako dodatnią liczbę całowitą:

      1.  #include <iostream>
      2.  using namespace std;
      3.  
      4.  int konwert(char* nap) {
      5.      int w = 0, i = 0, c;
      6.      while (c = nap[i++], c >= '0' && c <= '9')
      7.          w = 10*w + c - '0';
      8.      return w;
      9.  }
     10.  
     11.  int main() {
     12.      char tab1[] = "123a";
     13.      char tab2[] = "456 1";
     14.      char tab3[] = " 56";
     15.  
     16.      cout << "tab1 -> " << konwert(tab1) << endl;
     17.      cout << "tab2 -> " << konwert(tab2) << endl;
     18.      cout << "tab3 -> " << konwert(tab3) << endl;
     19.  }

Wynikiem jest

    tab1 -> 123
    tab2 -> 456
    tab3 -> 0

Kody ASCII kolejnych cyfr, 0, ..., 9, są kolejnymi liczbami całkowitymi (zeru odpowiada 48, jedynce — 49 itd., ale na szczęście nie musimy tych kodów pamiętać). Tak więc warunek c >= '0' && c <= '9' sprawdza, czy kod ASCII znaku c jest jednocześnie większy lub równy od kodu znaku '0' i mniejszy lub równy od kodu znaku '9', czyli czy jest to znak odpowiadający cyfrze. Jeśli nie, pętla zostanie przerwana.

Powtórnie wykorzystujemy ten mechanizm w następnej linii: wyrażenie c-'0' ma wartość liczbową równą liczbie reprezentowanej przez znak c. Jeśli np.  c jest znakiem '4', to '4'-'0' jest tym samym co 52 - 48, czyli 4 (tym razem liczbowo cztery). Zatem, jeśli kolejny wczytany znak jest cyfrą, to dotychczasowa wartość zmiennej w jest mnożona przez dziesięć, co odpowiada przesunięciu cyfr o jedną pozycję w lewo, i dodawana jest na pozycji jedności wartość liczbowa odpowiadająca wczytanej cyfrze. Pętla kończy się, gdy kolejnym znakiem nie jest cyfra. Dlatego tab2 zostanie zinterpretowana jako 456; wczytywanie zostanie zakończone, gdy napotkany zostanie odstęp pomiędzy cyfrą 6 a 1. Dla tab3 otrzymamy 0, bo pętla nie wykona ani jednego obrotu: jako pierwszy znak zostanie bowiem wczytany odstęp, a więc nie-cyfra.

---

Wstecz: 10. Konwersje niejawne, porządek W górę: 10. Konwersje niejawne, porządek Dalej: 10.2 Porządek wartościowania