Typy danych w C++: int, double, char, bool i inne

Dlaczego typy mają znaczenie w C++

Gdy deklarujesz wartość z jawnym typem, na przykład int age = 30;, typ to nie tylko etykieta. Mówi kompilatorowi, ile bajtów zarezerwować, jak te bajty interpretować i jakie operacje są dozwolone. Pomyl typ, a możesz po cichu stracić precyzję, doprowadzić do przepełnienia albo wywołać niezdefiniowane zachowanie.

C++ dzieli wbudowane typy na kilka rodzin: liczby całkowite, liczby zmiennoprzecinkowe, typ znakowy i typ logiczny. Przyjrzyjmy się każdej z nich, a potem regułom, na których ludzie się potykają.

Typy podstawowe

Oto po jednym z każdego podstawowego typu w jednym programie. Zwróć uwagę na przyrostki literałów (L, f, u) i pojedyncze cudzysłowy przy char:

#include <iostream>
using namespace std;

int main() {
    int    count = 42;          // liczba całkowita, zwykle 32-bitowa
    long long big = 9000000000LL; // szersza liczba całkowita, przyrostek LL
    double price = 19.99;       // 64-bitowa liczba dziesiętna (domyślna dla ułamków)
    float  ratio = 0.5f;        // 32-bitowa liczba dziesiętna: zwróć uwagę na f
    char   grade = 'A';         // pojedynczy znak, pojedyncze cudzysłowy
    bool   passed = true;       // tylko true albo false

    cout << count << " " << big << "\n";
    cout << price << " " << ratio << "\n";
    cout << grade << " " << passed << "\n"; // bool wypisuje się jako 1 / 0
}

bool domyślnie wypisuje się jako 1 albo 0, a nie true/false. char używa pojedynczych cudzysłowów: 'A' to jeden znak, a "A" (podwójne cudzysłowy) to literał napisowy, zupełnie inny typ. Te dwie pomyłki są na początku niezwykle częste.

Rozmiary nie są stałe

To największe zaskoczenie dla osób przychodzących z języków takich jak Java. Standard C++ gwarantuje tylko minimalne rozmiary i względną kolejność (short ≤ int ≤ long ≤ long long). Faktyczny rozmiar zależy od kompilatora i platformy. Zawsze sprawdzaj go przez sizeof:

#include <iostream>
using namespace std;

int main() {
    cout << "char:      " << sizeof(char)      << " byte\n";  // zawsze 1
    cout << "short:     " << sizeof(short)     << " bytes\n";
    cout << "int:       " << sizeof(int)       << " bytes\n";
    cout << "long:      " << sizeof(long)      << " bytes\n";
    cout << "long long: " << sizeof(long long) << " bytes\n";
    cout << "double:    " << sizeof(double)    << " bytes\n";
}

W typowej 64-bitowej kompilacji na Linuksie zobaczysz int = 4, long = 8. Na 64-bitowym Windowsie long ma jednak tylko 4 bajty. Ta luka w przenośności to dokładnie powód, dla którego nie należy pisać kodu zakładającego, że long jest 64-bitowy.

Gdy potrzebujesz dokładnej szerokości, sięgnij po typy całkowite o stałej szerokości z <cstdint>:

#include <iostream>
#include <cstdint>
using namespace std;

int main() {
    int8_t   a = -120;          // dokładnie 8 bitów, ze znakiem
    uint16_t b = 65000;         // dokładnie 16 bitów, bez znaku
    int32_t  c = 2000000000;    // dokładnie 32 bity
    int64_t  d = 9000000000LL;  // dokładnie 64 bity, na każdej platformie

    cout << (int)a << " " << b << " " << c << " " << d << "\n";
}

Używaj int32_t/int64_t w formatach plików, protokołach sieciowych i wszędzie tam, gdzie zachowanie musi być identyczne na różnych maszynach. Zwróć uwagę na rzutowanie (int)a: wysłanie 8-bitowego typu do strumienia wypisuje go jako znak, a nie liczbę, więc najpierw go rzutuj.

signed kontra unsigned

Każdy typ całkowity występuje w dwóch odmianach. Typ signed może przechowywać liczby ujemne; typ unsigned nie może, ale w zamian za zakres ujemny ma wyższe maksimum dodatnie. Zwykły int jest domyślnie ze znakiem.

#include <iostream>
#include <climits>
using namespace std;

int main() {
    unsigned int u = 0;
    u = u - 1;          // NIE staje się -1
    cout << u << "\n";  // zawija się do 4294967295 (maksimum unsigned int)

    cout << "int max:  " << INT_MAX << "\n";
    cout << "uint max: " << UINT_MAX << "\n";
}

Odejmowanie od 0 bez znaku zawija się do ogromnej liczby dodatniej zamiast zejść poniżej zera. To ciągle gryzie ludzi, zwłaszcza przy size_t (typie bez znaku) zwracanym przez .size():

vector<int> v = {1, 2, 3};
// UWAGA: v.size() jest bez znaku. Jeśli v jest pusty, v.size() - 1 zawija się
// do gigantycznej liczby, a pętla kręci się niemal w nieskończoność.
for (size_t i = 0; i <= v.size() - 1; i++) { /* ... */ }

Wybieraj i < v.size() (nigdy <= size() - 1) albo całkiem omiń problem dzięki pętli for po zakresie.

Przepełnienie liczb całkowitych to niezdefiniowane zachowanie

W przeciwieństwie do zawijania liczb bez znaku (które jest dobrze zdefiniowane), przepełnienie liczb całkowitych ze znakiem to w C++ niezdefiniowane zachowanie. Kompilator może zrobić cokolwiek: zwrócić śmieci, wyoptymalizować sprawdzenie albo doprowadzić do awarii:

#include <iostream>
#include <climits>
using namespace std;

int main() {
    int maxInt = INT_MAX;            // 2147483647
    cout << maxInt << "\n";
    cout << maxInt + 1 << "\n";      // NIEZDEFINIOWANE ZACHOWANIE: często zawija się na minus

    long long safe = (long long)maxInt + 1; // rozszerz przed dodawaniem
    cout << safe << "\n";            // 2147483648, poprawnie
}

Rozwiązanie jest takie samo jak przy pułapce przepełnienia w każdym języku: wykonuj obliczenia w szerszym typie. Rzutuj jeden z operandów na long long przed +, aby dodawanie odbyło się na 64 bitach. Rzutowanie wyniku po fakcie jest spóźnione, bo przepełnienie już nastąpiło.

Wybór właściwego typu

W większości kodu wartości domyślne są w porządku: int dla liczb całkowitych, double dla ułamków. Po coś innego sięgaj tylko wtedy, gdy masz powód.

Kilka pułapek do zapamiętania. float ma tylko około 7 znaczących cyfr dziesiętnych, więc 0.1f + 0.2f to nie dokładnie 0.3; wybieraj double, chyba że naprawdę musisz oszczędzać pamięć. A char może być ze znakiem lub bez, zależnie od platformy, więc jeśli wykonujesz obliczenia na surowych bajtach, pisz jawnie signed char albo unsigned char.

Dalej: słowo kluczowe auto

Wypisywanie typu za każdym razem bywa żmudne, a czasem typ jest długi albo trudny do nazwania. C++ pozwala kompilatorowi wywnioskować go za ciebie dzięki słowu kluczowemu auto: auto x = 42; sprawia, że x jest typu int, a auto it = v.begin(); oszczędza ci wpisywania rozwlekłego typu iteratora. Następna strona pokazuje, kiedy auto czyni kod czytelniejszym, a kiedy ukrywa za dużo.