obrazek

Prezentowane materiały są przeznaczone dla uczniów szkół ponadgimnazjalnych.
Autor artykułu: mgr Jerzy Wałaszek, wersja1.0

obrazek

Typy zmiennych w języku C++

Typy całkowite

Zmienne całkowite mogą przechowywać liczby całkowite. W języku C++ (kompilator Mingw) rozróżniamy następujące typy całkowite:

int

32 bitowe liczby całkowite w kodzie U2.
Zakres: -2³¹...2³¹ - 1, -2147483648...2147483647.
Każda zmienna int zajmuje w pamięci komputera 4 bajty.

unsigned int

32 bitowe liczby całkowite w naturalnym kodzie binarnym.
Zakres: 0...2³² - 1, 0...4294967295.
Każda zmienna unsigned int zajmuje w pamięci komputera 4 bajty.

short int

16 bitowe liczby całkowite w kodzie U2.
Zakres: -2¹⁵...2¹⁵ - 1, -32768...32767.
Każda zmienna short int zajmuje w pamięci komputera 2 bajty.

unsigned short int

16 bitowe liczby całkowite w naturalnym kodzie binarnym.
Zakres: 0...2¹⁶ - 1, 0...65535.
Każda zmienna unsigned short int zajmuje w pamięci komputera 2 bajty.

char

8 bitowe liczby całkowite w kodzie U2.
Zakres: -2⁷...2⁷ - 1, -128...127.
Każda zmienna char zajmuje w pamięci komputera 1 bajt. Typ ten jest interpretowany przez operacje wejścia wyjścia jako typ znakowy - jedna zmienna char może przechować jeden znak ASCII. Poza tym zmienne char możemy traktować jak zwykłe zmienne całkowite.

unsigned char

8 bitowe liczby całkowite w naturalnym kodzie binarnym.
Zakres: 0 do 2⁸ - 1, 0...255.
Każda zmienna unsigned char zajmuje w pamięci komputera 1 bajt. Typ ten jest interpretowany przez operacje wejścia wyjścia jako typ znakowy.

long long int

64 bitowe liczby całkowite w kodzie U2.
Zakres: -2⁶³...2⁶³ - 1, -9223372036854775808...9223372036854775807.
Każda zmienna long long int zajmuje w pamięci komputera 8 bajtów.

unsigned long long int

64 bitowe liczby całkowite w naturalnym kodzie binarnym.
Zakres: 0...2⁶⁴ - 1, 0...18446744073709551615.
Każda zmienna unsigned long long int zajmuje w pamięci komputera 8 bajtów.

Typy int i unsigned int są typami podstawowymi (ang. generic types), które procesor 32-bitowy przetwarza najefektywniej (jest zoptymalizowany do takiego rozmiaru danych). Dlatego będziemy je stosowali najczęściej. Pozostałe typy pochodne (za wyjątkiem char dla znaków) stosuje się tylko w szczególnych sytuacjach.

Przy obliczeniach wynik może przekroczyć dozwolony zakres wartości dla danego typu całkowitego, co prowadzi do błędów. Uruchom poniższy program.

// (C)2010 Koło Informatyczne I LO
//
// Przekroczenie zakresu
//--------------------------------

#include <iostream>

using namespace std;

int main()
{
    int a = 2147483647;
    cout << a << endl;
    a = a + 1;          // zmienną zwiększamy o 1!
    cout << a << endl;
    return 0;
}

Typy zmiennoprzecinkowe

Do przechowywania liczb ułamkowych używamy zmiennych typu zmiennoprzecinkowego (ang. floating point type). W typach zmiennoprzecinkowych ważniejszym parametrem od zakresu jest tzw. precyzja, która określa dokładność zapamiętywania liczb.

float

32 bitowe liczby zmiennoprzecinkowe o pojedynczej precyzji.
Precyzja 7-8 cyfr.
Każda zmienna float zajmuje w pamięci komputera 4 bajty.

double

64 bitowe liczby zmiennoprzecinkowe o podwójnej precyzji.
Precyzja 15 cyfr.
Każda zmienna double zajmuje w pamięci komputera 8 bajtów.

long double

80 bitowe liczby zmiennoprzecinkowe o rozszerzonej precyzji.
Precyzja 20 cyfr.
Każda zmienna long double zajmuje w pamięci komputera 12 bajtów, z których na dane wykorzystuje się tylko 10, a 2 są uzupełnieniem do granicy słów 4-bajtowych. Słowa 4 bajtowe procesor Pentium pobiera z pamięci w jednym cyklu i stąd takie rozwiązanie.

Typem podstawowym jest obecnie double. Typu float zwykle nie używa się ze względu na niską precyzję. Typ long double jest wewnętrznym typem koprocesora arytmetycznego. Ponieważ jest nieprzenośny na inne platformy sprzętowe, nie jest polecany. Uruchom poniższy program:

// (C)2010 Koło Informatyczne I LO
//
// Przekroczenie precyzji
//--------------------------------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    float x;
    x = 123456789;
    cout << fixed << x << endl;
    return 0;
}

Typ logiczny

bool

1 bitowa dana logiczna.
Każda zmienna bool zajmuje w pamięci komputera 1 bajt. Wartość zmiennej jest przechowywana w najmłodszym bicie. Pozostałe 7 bitów jest niewykorzystywane.

Przy przypisywaniu wartości zmiennej kompilator C++ dokonuje niejawnej konwersji:

zmienna = wyrażenie;

Wartość wyrażenia jest obliczana, a następnie dokonana zostaje konwersja tej wartości zgodnie z typem zmiennej. Dla zmiennych bool wartość wyrażenia różna od 0 oznacza prawdę - zostanie ustawiony ostatni bit zmiennej i w efekcie otrzymamy wartość 1:

// (C)2010 Koło Informatyczne I LO
//
// Wartość logiczna
//--------------------------------

#include <iostream>

using namespace std;

int main()
{
    bool x;
    x = 652;
    cout << x << endl;
    return 0;
}

Czy można zmusić zmienną typu bool do przechowywania innej wartości niż 0 lub 1? Można, ale tylko pośrednio - wykorzystując wskaźniki:

// (C)2010 Koło Informatyczne I LO
//
// Wartość logiczna
//--------------------------------

#include <iostream>

using namespace std;

int main()
{
    bool x;
    char * p;          // wskaźnik do zmiennej typu char
    p = (char *) & x;  // w p umieszczamy adres x
    * p = 65;          // do x zapisujemy 65
    cout << x << endl; // i wynik!
    return 0;
}

Podsumowanie

Rozmiar obiektu lub typu zwraca operator sizeof(), do którego możemy przekazać zmienną lub typ. Wynikiem jest liczba bajtów pamięci, w której zostanie zapisany obiekt danego typu. Uruchom poniższy program:

// (C)2010 Koło Informatyczne I LO
// Rozmiary typów danych
//--------------------------------

#include <iostream>

using namespace std;

int main()
{
    cout << "                   int : " << sizeof (int) << endl
         << "          unsigned int : " << sizeof (unsigned) << endl
         << "             short int : " << sizeof (short) << endl
         << "    unsigned short int : " << sizeof (unsigned short) << endl
         << "                  char : " << sizeof (char) << endl
         << "         unsigned char : " << sizeof (unsigned char) << endl
         << "         long long int : " << sizeof (long long) << endl
         << "unsigned long long int : " << sizeof (unsigned long long) << endl
         << "                 float : " << sizeof (float) << endl
         << "                double : " << sizeof (double) << endl
         << "           long double : " << sizeof (long double) << endl
         << "                  bool : " << sizeof (bool) << endl;

    return 0;
}

Dokument ten rozpowszechniany jest zgodnie z zasadami licencji
GNU Free Documentation License.

Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl

W artykułach serwisu są używane cookies. Jeśli nie chcesz ich otrzymywać,
zablokuj je w swojej przeglądarce.
Informacje dodatkowe