Informatyka dla klasy IIK

Język C++ zawiera cały szereg typów danych dla liczb całkowitych. Podstawowym typem jest typ int. Odzwierciedla on typowe dane całkowite dla danej architektury. Używana przez nas wersja Code::Blocks pracuje w architekturze 32-bitowej, zatem typ int będzie się odnosił do danych 32-bitowych.

Aby sprawdzić rozmiar typu int, uruchom poniższy program:

// Typy całkowite
//-----------------

#include <iostream>

using namespace std;

int main()
{
    cout << sizeof(int) << endl;
    return 0;
}

Jeśli otrzymasz wynik 4, to znaczy, że standardowy typ całkowity int zajmuje w pamięci komputera 4 bajty, czyli 4 x 8 = 32 bity.

Typ int odnosi się do danych zapisanych w 32-bitowym kodzie U2. Zakres możliwych wartości zawiera się w przedziale od -2³¹ do 2³¹ - 1, czyli od -2147483648 do 2147483647, zapamiętaj: +/- 2 miliardy.

Jeśli poprzedzimy typ int modyfikatorem unsigned, to otrzymamy typ całkowity dla liczb dodatnich i zera. Dana typu unsigned int (int można pominąć) ma ten sam rozmiar co typ int, czyli w naszym przypadku 4 bajty, 32 bity. Typ unsigned oznacza 32-bitową daną w naturalnym kodzie binarnym o zakresie wartości od 0 do 2³² - 1, czyli od 0 do 4294967297, zapamiętaj: 0...4 miliardy. Typu unsigned używamy, gdy nasz program nie operuje na liczbach ujemnych. W takim przypadku mamy większy zakres liczb dodatnich.

Oprócz modyfikatora unsigned do typu int możemy dodać:

Jako liczby całkowite można również używać kody znaków ASCII, które są 8-bitowe. Podstawowy typ znakowy (kod jednego znaku) w C++ nosi nazwę char. Oznacza on 8-bitową liczbę U2 o zakresie od -2⁷ do 2⁷-1, od -128 do 127. Typ unsigned char oznacza 8-bitową liczbę w kodzie NBC o zakresie od 0 do 2⁸-1, od 0 do 255.

Typy danych na różnych platformach mogą mieć różny rozmiar w pamięci. Dlatego rozpoczynając pracę z nowym środowiskiem C++ dobrze jest je sobie sprawdzić, np. poniższym programem:

// Typy całkowite
//-----------------

#include <iostream>

using namespace std;

int main()
{
    cout << "char      : " << sizeof(char) << " B\n"
         << "short     : " << sizeof(short) << " B\n"
         << "int       : " << sizeof(int) << " B\n"
         << "long      : " << sizeof(long) << " B\n"
         << "long long : " << sizeof(long long) << " B\n";
    return 0;
}

Podsumujmy typy całkowite dla Code::Blocks:

Najczęściej będziemy używać typu int oraz unsigned. Pozostałe typy używa się w wyjątkowych sytuacjach.

Liczby zmiennoprzecinkowe

W obliczeniach naukowych musimy operować wartościami niecałkowitymi. Dlatego język C++ został wyposażony w nowy typ danych – liczby rzeczywiste. Zanim do nich przejdziemy, zapoznajmy się ze sposobami zapisu liczb rzeczywistych w komputerze. Odpowiedzmy sobie na proste pytanie – czy wykorzystując tylko liczby całkowite, można zapisywać również liczby ułamkowe? Na fizyce zapewne spotkałeś się wielokrotnie z zapisem bardzo dużych lub bardzo małych wartości. Robiono to na przykład tak:

2,5 × 10³⁶

lub tak:

3,3 × 10^-31

Ogólnie możemy to zapisać następująco:

W  = m  × p^c

gdzie:

W  – wartość liczby
m  – mantysa
p  – podstawa
c  – cecha

Podstawa p  jest zwykle stała, w systemie dziesiętnym wynosi 10. Zatem nie musimy jej zapamiętywać – po prostu wiemy, że wynosi 10. Pozostają do zapamiętania dwie pozostałe liczby: m  – mantysa i c  – cecha. Znając je możemy obliczyć wartość liczby W. Zwróć uwagę, że daną wartość W  otrzymasz dla wielu zestawów m  i c.

Przykłady:

c  = 1
m  = 3
W  = 3 × 10¹ = 3 × 10 = 30

c  = 0
m  = 30
W  = 30 × 10⁰ = 30 × 1 = 30

c  = 2
m  = 0,3
W  = 0,3 × 10² = 0,3 × 100 = 30

Jeśli naszą liczbę zapiszemy w postaci pary liczb (c,m), to następujące pary odpowiadają tej samej wartości W: (3,1)  (30,0)   (0,3 2). Cecha jest zawsze liczbą całkowitą, a te już znamy. Mantysa jest liczbą ułamkową. Aby standaryzować zapis, możemy się umówić, że mantysa jest ZAWSZE ułamkiem właściwym o mianowniku np. 1000. Skoro tak, to licznik tego ułamka jest liczbą całkowitą od -999 do 999. Skoro mianownik jest ustalony, to nie musimy go zapamiętywać – wystarczy nam licznik, aby odtworzyć wartość mantysy.

Przykład:

Niech m  oznacza u nas licznik mantysy, mianownik mantysy ma stałą wartość 1000 (bo tak się umawiamy).

c  = 2
m  = 3
W  = ³/₁₀₀₀ × 10² = ³/₁₀₀₀ × 100 = ³/₁₀ = 0,3 – liczba ułamkowa dla pary (2,3).

Pomimo iż pamiętamy jedynie liczby całkowite, wartość reprezentowanej przez nie liczby jest ułamkowa. Zatem liczby rzeczywiste możemy zapamiętywać w postaci pary dwóch liczb całkowitych – cechy oraz licznika mantysy. Tak właśnie komputer zapamiętuje liczby rzeczywiste – w postaci dwóch liczb całkowitych, które wspólnie razem tworzą tzw. kod zmiennoprzecinkowy (ang floating point code). Komputer pracuje w systemie dwójkowym, zatem mantysa jest ułamkiem binarnym – mianownik jest zawsze potęgą liczby 2 (w systemie praktycznym jest to dosyć duża potęga, np. 2⁵³). Komputer w kodzie zmiennoprzecinkowym zapamiętuje jedynie licznik tego ułamka. Podstawa p  wynosi 2. Znając mianownik ułamka mantysy 2^x  oraz jego licznik m  i cechę c  możemy wyliczyć wartość dowolnej liczby zmiennoprzecinkowej:

W  = m  / 2^x × 2^c

m  – licznik mantysy, liczba całkowita
2^x  – mianownik mantysy, stała wartość, nie pamiętana w kodzie zmiennoprzecinkowym
c  – cecha

Przykład:

Niech mianownik ułamka mantysy wynosi 16 (2⁴). Zatem licznik może przybierać wartości od -16 do 15. Obliczmy wartości kilku binarnych liczb zmiennoprzecinkowych:

c  = 2
m  = 1
W  = 1 / 2⁴  × 2² = 1 / 2² = ¹/₄ = 0,25

c  = -3
m  = 5
W  = 5 / 2⁴ × 2^-3 = 5 / 2⁴ × 1 / 2³ = 5 / 2⁷ = ⁵/₁₂₈

c  = 1
m  = 12
W  = 12 / 2⁴ × 2¹ = 12 / 2³ = ¹²/₈ = 1 ⁴/₈ = 1 ¹/₂ = 1,5

Widzimy, że obliczenia nie są skomplikowane. Wyznaczenie licznika mantysy m  i cechy c  jest równie proste. Wykorzystujemy tu proste przekształcenia matematyczne w celu sprowadzenia mantysy do ułamka właściwego. Obliczmy przykładowo m  i c  dla liczby 2,5.

Najpierw zapisujemy liczbę 2,5 w postaci ułamka o mianowniku 16:

2,5 = ⁵/₂ = ⁴⁰/₁₆

Teraz zapisujemy mantysę i cechę wstępną równą 0:

3,5 = ⁴⁰/₁₆ × 2⁰

Mantysę musimy sprowadzić do ułamka właściwego. Zatem licznik dzielimy przez 2, a do cechy dodajemy 1. Operację tę kontynuujemy do momentu, aż mantysa stanie się ułamkiem właściwym:

⁴⁰/₁₆ × 2⁰ = ²⁰/₁₆ × 2¹ = ¹⁰/₁₆ × 2².

Dostaliśmy:

c  = 2 i m  = 10.

Pewnych liczb nie da się dokładnie przedstawić w tym systemie. Spróbujmy zapisać liczbę 17 przy założeniu, że mantysa jest ułamkiem właściwym o mianowniku 16.

17 = ²⁷²/₁₆ × 2⁰ = ¹³⁶/₁₆ × 2¹ = ⁶⁸/₁₆ × 2² = ³⁴/₁₆ × 2³ = ¹⁷/₁₆ × 2⁴ = ⁸/₁₆ × 2⁵

W ostatnim działaniu przyjęliśmy 8 jako wynik dzielenia 17 przez 2, ponieważ licznik ułamka musi być liczbą całkowitą. To zaokrąglenie spowodowało, że pierwotna liczba 17 zostaje sprowadzona do liczby:

c  = 5
m  = 8
W  = 8/2⁴ × 2⁵ = 8 × 2¹ = 8 × 2 = 16!

Wniosek – jeśli mantysa jest ułamkiem o mianowniku 16, to liczby 17 nie da się przedstawić dokładnie. Gdyby mantysa była ułamkiem o mianowniku większym, np. 32, problem ten nie wystąpiłby dla liczby 17, ale pojawiłby się z kolei dla liczby 33. Zatem jest to stała cecha tego zapisu.

W rzeczywistym systemie mantysa jest ułamkiem o mianowniku bardzo dużym, np. 2⁵⁶. Pozwala to zapisywać liczby z dużą dokładnością. Ale błędy zaokrągleń dają czasami znać o sobie, co zobaczymy w dalszych przykładach. Więcej informacji na ten temat znajdziesz w artykule o binarnym kodowaniu liczb.

float – dane zmiennoprzecinkowe 32 bitowe, pojedynczej precyzji. Dokładność 7-8 cyfr znaczących.

double – dane zmiennoprzecinkowe 64 bitowe podwójnej precyzji. Dokładność 15 cyfr znaczących.

long double – dane zmiennoprzecinkowe 80 bitowe o rozszerzonej precyzji. Dokładność 20 cyfr znaczących.

Typ float jest najmniej dokładnym typem danych rzeczywistych. Jedyną jego zaletą jest mały rozmiar – 32 bity. Dzisiaj nie zaleca się jego stosowania.

Typ double jest standardowym typem rzeczywistym. Jeśli nie będą istniały specjalne powody, to będziemy stosować w programach tylko typ double.

Typ long double jest typem danych, które wewnętrznie wykorzystuje koprocesor arytmetyczny – jest to część procesora Pentium wykonująca operacje zmiennoprzecinkowe. Typ ten pozwala zminimalizować błędy zaokrągleń i zachować dużą precyzję obliczeń. Jednakże nie będziemy z niego korzystać, ponieważ może nie być dostępny na innych platformach sprzętowych – koprocesory mają różne standardy w różnych systemach.

// Obliczanie pola i obwodu prostokąta
// (C)2017 I LO w Tarnowie
//------------------------

#include <iostream>

using namespace std;

int main()
{
    double a,b,pole,obwod;

    cout << "a = "; cin >> a;
    cout << "b = "; cin >> b;

    pole  = a * b;
    obwod = 2 * (a + b);

    cout << endl
         << "Obwod = " << obwod << endl
         << "Pole  = " << pole << endl;

    return 0;
}

Powyższy program, chociaż działa doskonale posiada kilka wad z punktu widzenia użytkownika. Uruchom go i wprowadź poniższe dane:

Zwróć uwagę, że wynik nie jest odpowiednio wyrównany. Kropki dziesiętne znajdują się w różnych kolumnach.  Liczba miejsc po przecinku jest różna. A teraz wpisz takie dane:

Ponieważ wynik jest dużą liczbą, to komputer przedstawia go w postaci naukowej

Aby mieć pełną kontrolę nad sposobem prezentacji liczb zmiennoprzecinkowych przez konsolę, musimy użyć tzw. manipulatorów strumienia. W tym celu należy do programu dołączyć plik nagłówkowy iomanip, który zawiera definicję tych manipulatorów. Manipulatory przesyłamy do strumienia jak zwykłe dane. W poniższej tabelce zebraliśmy podstawowe manipulatory strumienia cout.

cout << setw(6) << a << endl;

cout << setw(6) << setfill('0') << a << endl;

Nasz program po zastosowaniu manipulatorów wygląda następująco:

// Obliczanie pola i obwodu prostokąta
// (C)2017 I LO w Tarnowie
//------------------------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    double a,b,pole,obwod;

// ustawiamy stałoprzecinkowe wyświetlanie liczb rzeczywistych
// z czterema cyframi po przecinku

    cout << fixed << setprecision(4);

    cout << "a = "; cin >> a;
    cout << "b = "; cin >> b;

    pole  = a * b;
    obwod = 2 * (a + b);

    cout << endl
         << "Obwod = " << setw(12) << obwod << endl
         << "Pole  = " << setw(12) << pole << endl;

    return 0;
}

Liczby zmiennoprzecinkowe są liczbami przybliżonymi. Typ double pozwala reprezentować dokładnie tylko 15 cyfr znaczących. Jeśli liczba ma ich więcej, to tylko 15 pierwszych cyfr będzie dokładne. Pozostałe już nie.

// Precyzja liczby zmiennoprzecinkowej
// (C)2017 I LO w Tarnowie
//------------------------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    double x;

    cout << fixed;

    x = 12345678901234567890.0; // x ma dwadzieścia cyfr

    cout << x << endl;

    return 0;
}

// Precyzja liczby zmiennoprzecinkowej
// (C)2017 I LO w Tarnowie
//------------------------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    double x;

    cout << fixed << setprecision(20);

    x = 0.1234567890123456789; // x ma dwadzieścia cyfr

    cout << x << endl;

    return 0;
}

Niektóre liczby nie będą nigdy reprezentowane dokładnie, chociaż posiadają mniej niż 15 cyfr znaczących. Typowym przykładem jest ułamek 0,1. Ponieważ mantysa liczby zmiennoprzecinkowej jest ułamkiem dwójkowym (mianownik tego ułamka jest potęgą liczby 2), to wartości 0,1 nie da się nigdy przedstawić dokładnie, zawsze będzie istniał pewien błąd.

Poniższe ułamki dwójkowe są prawie równe 0,1. Ale "prawie" nie oznacza wcale, że są równe:

¹/₈,  ¹/₁₆,  ³/₃₂,  ⁶/₆₄,  ¹²/₁₂₈,  ²⁵/₂₅₆,  ¹⁰²/₁₀₂₄,  ⁶⁵⁵³/₆₅₅₃₅ ...

Ułamek dziesiętny 0,1 posiada w systemie dwójkowym nieskończone rozwinięcie. W naszym systemie dziesiętnym podobną własność mają ułamki ¹/₃, ¹/₆, ¹/₇, ¹/₉ – ułamków tych nie da się przedstawić dokładnie za pomocą skończonej ilości cyfr w systemie dziesiętnym. Tak samo w systemie dwójkowym, ułamka ¹/₁₀ nie da się przedstawić dokładnie za pomocą mantysy o skończonej liczbie bitów. Konsekwencje tego faktu prezentuje poniższy prosty program:

// Niedokładny ułamek 1/10
// (C)2017 I LO w Tarnowie
//------------------------

#include <iostream>

using namespace std;

int main()
{
    double x;

    x = 0.1;

    x += 0.1; // 0,2
    x += 0.1; // 0,3
    x += 0.1; // 0,4
    x += 0.1; // 0,5
    x += 0.1; // 0,6
    x += 0.1; // 0,7
    x += 0.1; // 0,8
    x += 0.1; // 0,9
    x += 0.1; // 1

    cout << "x = " << x << endl;
    
    if(x == 1) cout << "Dobrze!";
    else       cout << "Zle!!!";

    cout << endl;

    return 0;
}

Program dodaje do zmiennej x ułamek 0,1. Po wykonaniu 9 takich dodawań x powinno osiągnąć wartość 1 i na ekranie powinien pojawić się tekst Dobrze!. Tymczasem po uruchomieniu programu pojawia się ten drugi tekst, pomimo że program wyświetla wartość x jako 1. Powodem jest to, iż po wykonaniu 9 dodawań 0,1 w zmiennej x nie była dokładnie wartość 1, tylko wartość bardzo zbliżona do 1. Niestety, operator == traktuje ją jako różną od 1.

Z programu powyższego wynika BARDZO WAŻNY wniosek – liczb zmiennoprzecinkowych NIE WOLNO przyrównywać do wartości dokładnych. Zamiast sprawdzania, czy dwie liczby  zmiennoprzecinkowe a i b są równe:

a == b

powinniśmy zbadać ich różnicę. Jeśli ta różnica jest dostatecznie mała, to przyjmiemy, że liczby a i b są równe. Różnica może być dodatnia lub ujemna. Aby nie rozważać zatem dwóch różnych przypadków, będziemy badać wartość bezwzględną różnicy:

| a - b | < wartość graniczna

Wartość bezwzględna liczby zmiennoprzecinkowej oblicza funkcja fabs(x). Dostęp do tej funkcji uzyskamy po dołączeniu do programu pliku nagłówkowego cmath. Za wartość graniczną przyjmiemy 0.0000001. W tym celu w programie zdefiniujemy stałą EPS o takiej właśnie wartości. W pętli while mamy warunek x różne od 1. Otrzymamy go następująco:

fabs(x - 1) > EPS

A oto zmodyfikowany program, który teraz działa wg oczekiwań:

// Niedokładny ułamek 1/10
// (C)2017 I LO w Tarnowie
//------------------------

#include <iostream>
#include <cmath>

using namespace std;

const double EPS = 0.0000001;

int main()
{
    double x;

    x = 0.1;

    x += 0.1; // 0,2
    x += 0.1; // 0,3
    x += 0.1; // 0,4
    x += 0.1; // 0,5
    x += 0.1; // 0,6
    x += 0.1; // 0,7
    x += 0.1; // 0,8
    x += 0.1; // 0,9
    x += 0.1; // 1

    cout << "x = " << x << endl;
    
    if(fabs(x - 1) < EPS) cout << "Dobrze!";
    else                  cout << "Zle!!!";

    cout << endl;

    return 0;
}

Na liczby zmiennoprzecinkowe trzeba bardzo uważać w programowaniu. Musimy pamiętać, że są to wartości przybliżone. Błąd w stosunku do wartości dokładnej jest zwykle bardzo mały, ale może powodować błędne działanie programu, jeśli nie weźmiemy tego faktu pod uwagę. Następny program znajduje pierwiastki równania kwadratowego:

Algorytm znajdowania pierwiastków jest następujący:

Obliczamy wyróżnik równania:

W zależności od wartości wyróżnika mamy trzy przypadki:

Istnieje pierwiastek podwójny, który obliczamy ze wzoru:

Istnieją dwa różne pierwiastki, które obliczamy ze wzorów:

Nie ma pierwiastków rzeczywistych.

Algorytm wymaga obliczania pierwiastka kwadratowego, który udostępni nam funkcja sqrt(x), dostępna po dołączeniu pliku nagłówkowego cmath.

// Równanie kwadratowe
// (C)2017 I LO w Tarnowie
//------------------------

#include <iostream>
#include <iomanip>
#include <cmath>

using namespace std;

const double EPS = 0.0000001;

int main()
{
  double a,b,c,delta,x1,x2;

  cout << fixed << setprecision(4);

  cout << "Rozwiązywanie równania kwadratowego\n"
          "-----------------------------------\n\n"
          "    2\n"
          "  ax + bx + c = 0\n\n";

  cout << "  a = "; cin >> a;
  cout << "  b = "; cin >> b;
  cout << "  c = "; cin >> c;

  cout << endl;

  delta = b*b - 4*a*c;

  if(fabs(delta) < EPS)
  {
    cout << "  Jeden pierwiastek podwojny:\n\n";

    x1 = -b / 2 / a;

    cout << "  x = " << x1 << endl;
  }
  else if(delta > 0)
  {
    cout << "  Dwa rozne pierwiastki:\n\n";

    x1 = (-b - sqrt(delta)) / 2 / a;
    x2 = (-b + sqrt(delta)) / 2 / a;

    cout << "  x1 = " << setw(14) << x1 << endl
         << "  x2 = " << setw(14) << x2 << endl << endl;
  }
  else cout << "  Brak pierwiastkow rzeczywistych\n\n";

  return 0;
}

Program sprawdź dla trzech poniższych równań kwadratowych:

x² - 2x  + 1 = 0,   pierwiastek podwójny x₁ = x₂ = 1
x² - 3x  + 2 = 0,   dwa pierwiastki różne: x₁ = 1,  x₂ = 2
x² + x  + 1 = 0,    brak pierwiastków.