Matura - programowanie w C++

W języku C++ mamy do dyspozycji liczby całkowite oraz liczby zmiennoprzecinkowe. Liczba jest całkowita, jeśli nie posiada kropki dziesiętnej.

Uruchom Code::Blocks i utwórz projekt o kolejnym numerze, np. 002 (aplikacja konsoli). Projekt utwórz w katalogu, który do tego celu przygotowałeś (u mnie C:\lekcje). W edytorze wpisz program:

// Program 002
// Liczby
// -----------

#include <iostream>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    cout << "Liczby całkowite" << endl
         << "================" << endl << endl
         << 1 << " " << -77 << " " << 12693 << endl;
    return 0;
}

Program wypisze w oknie konsoli tekst:

Liczby całkowite
================

1 -77 12693

Zwróć uwagę, iż pomiędzy liczbami przesyłane są do strumienia spacje " ". Jeśli ich nie prześlesz, to cyfry liczb połączą się w jeden ciąg i wynik stanie się nieczytelny.

Zmieńmy program tak, aby liczby były wyświetlane jedna pod drugą:

// Program 002
// Liczby
// -----------

#include <iostream>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    cout << "Liczby całkowite" << endl
         << "================" << endl << endl
         << 1 << endl
         << -77 << endl
         << 12693 << endl;
    return 0;
}

Liczby całkowite
================

1
-77
12693

Liczby są niewyrównane w kolumnie, co utrudnia ich czytanie. Wyrównajmy je zatem, zmień program:

// Program 002
// Liczby
// -----------

#include <iostream>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    cout << "Liczby całkowite" << endl
         << "================" << endl << endl
         <<     1 << endl
         <<   -77 << endl
         << 12693 << endl;
    return 0;
}

Skompiluj i uruchom go. Zmieniło się coś? Nie, ponieważ strumień nie reaguje na spacje nie będące tekstem. Spacja w języku C++ jest tzw. separatorem, czyli znakiem, który separuje, rozdziela elementy w wierszu (tutaj operator przesłania << oraz liczbę). Liczy się tylko pierwszy separator, reszta jest ignorowana, możesz sobie wstawić milion spacji, a i tak zadziałają jak jedna - to się przydaje, gdy chcemy ładnie wypozycjonować elementy programu (aby program wyglądał schludnie :)).

Jeśli chcemy wypozycjonować tekst przesyłany do strumienia, musimy skorzystać z manipulatorów. Poznaliśmy już jeden z nich: endl, który kończy wiersz tekstu. Manipulatorów jest więcej, ale aby były dostępne w programie, musisz dołączyć do niego plik nagłówkowy iomanip (manipulatory wejścia/wyjścia). Dopisz do programu:

...
#include <iostream>
#include <iomanip>
...

Przed każdą wyświetlaną w kolumnie liczbą wyślemy do strumienia manipulator setw(n):

// Program 002
// Liczby
// -----------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    cout << "Liczby całkowite" << endl
         << "================" << endl << endl
         << setw(5) <<     1 << endl
         << setw(5) <<   -77 << endl
         << setw(5) << 12693 << endl;
    return 0;
}

Teraz wynik wygląda następująco:

Liczby całkowite
================

    1
  -77
12693

Manipulator setw(n) (ang. set width – ustaw szerokość) wymaga parametru n i działa następująco:

1. Tworzone jest pole o szerokości n znaków, które standardowo wypełnione zostaje spacjami.
2. W polu tym jest umieszczany następny element przesłany do strumienia (i tylko on).
3. Element ten standardowo jest dosuwany do prawej krawędzi pola.

W naszym programie ustawiliśmy szerokości pól na 5 znaków, bo tyle cyfr ma największa liczba 12693. Dzięki manipulatorom setw( ) liczby zostały wyświetlone w kolumnie z wyrównaniem na prawo.

Jeśli w liczbie umieścimy kropkę (w systemie anglosaskim odpowiada ona naszemu przecinkowi dziesiętnemu), to liczba zostanie potraktowana jako zmiennoprzecinkowa.

Zmień program na następujący:

// Program 002
// Liczby
// -----------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    cout << "Liczby zmiennoprzecinkowe" << endl
         << "=========================" << endl << endl
         << 1.5 << endl
         << -77.51 << endl
         << 126931396.6 << endl;
    return 0;
}

Po skompilowaniu i uruchomieniu otrzymasz wynik:

Liczby zmiennoprzecinkowe
=========================

1.5
-77.51
1.26931e+08

Co się stało z ostatnią liczbą? Komputer po prostu przeszedł na notację naukową, ponieważ liczba jest dla niego duża. Zapis ten należy zinterpretować jako:

1.26931e+08 = 1,26931 × 108

Literka e pochodzi od angielskiego słowa exponent (wykładnik). Ten sposób prezentacji liczb używany jest w kalkulatorach naukowych.

Jeśli nie chcemy, aby liczby zmiennoprzecinkowe były prezentowane w notacji naukowej, to wysyłamy do strumienia cout na początku programu manipulator fixed (ustalony, stały):

// Program 002
// Liczby
// -----------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    cout << fixed;

    cout << "Liczby zmiennoprzecinkowe" << endl
         << "=========================" << endl << endl
         << 1.5 << endl
         << -77.51 << endl
         << 126931396.6 << endl;
    return 0;
}

Wynik jest następujący:

Liczby zmiennoprzecinkowe
=========================

1.500000
-77.510000
126931396.600000

Manipulator fixed ma działanie globalne, czyli wystarczy go użyć raz w programie gdzieś na początku przed wyświetlaniem liczb. Liczby zmiennoprzecinkowe są standardowo wyświetlane z sześcioma cyframi po przecinku (kropce dziesiętnej w systemie anglosaskim). Możemy to łatwo zmienić za pomocą manipulatora setprecision(n), który globalnie ustawia n cyfr po przecinku w liczbie zmiennoprzecinkowej:

// Program 002
// Liczby
// -----------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    cout << fixed << setprecision(2);

    cout << "Liczby zmiennoprzecinkowe" << endl
         << "=========================" << endl << endl
         << 1.5 << endl
         << -77.51 << endl
         << 126931396.6 << endl;
    return 0;
}

Liczby zmiennoprzecinkowe
=========================

1.50
-77.51
126931396.60

Pozostaje nam wypozycjonowanie liczb w kolumnie. Wykorzystamy tu manipulatory setw(n):

// Program 002
// Liczby
// -----------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    cout << fixed << setprecision(2);

    cout << "Liczby zmiennoprzecinkowe" << endl
         << "=========================" << endl << endl
         << setw(12) << 1.5 << endl
         << setw(12) << -77.51 << endl
         << setw(12) << 126931396.6 << endl;
    return 0;
}

Liczby zmiennoprzecinkowe
=========================

        1.50
      -77.51
126931396.60

Do zapamiętania:

• Manipulator setw(n).
• Manipulator fixed.
• Manipulator setprecision(n).
• Wyrównywanie liczb w kolumnie.

Język C++ wymaga, aby każda zmienna została zdefiniowana przed jej użyciem w programie. Definicja zmiennej składa się z dwóch elementów:

typ nazwa;

Z lekcji "Istota informatyki" wiesz, że bity są jedynie nośnikiem informacji. Najważniejsza jest ich interpretacja. Komputer musi "wiedzieć", jak traktować dane bity, aby móc z nich skorzystać. Typ zmiennej daje mu taką właśnie informację. Typy poznamy w dalszej części kursu.

Nazwa zmiennej w języku C++ jest zbudowana z liter (małych lub dużych, które są rozróżniane, polskie znaki nie są dozwolone), cyfr oraz znaku podkreślenia "_". Nazwa zmiennej nie może się rozpoczynać od cyfry (gdyż wtedy komputer potraktowałby zmienną jak liczbę) oraz nazwa nie może być identyczna z nazwą innej zmiennej lub ze słowem kluczowym języka C++. Niepoprawne są zatem nazwy (dlaczego?):

12X, 0_1, return, int, main...

Poprawne nazwy:

_0, Main, Return, wynik, pole_kola, obw12...

Tworząc zmienne staraj się nadawać im proste nazwy, które jednak informują o przeznaczeniu zmiennej w twoim programie. Nazwy typu a87XcQz8_em są poprawne, lecz mało czytelne i łatwo w nich o pomyłkę. W nazwie zwykle tylko pewna liczba początkowych znaków jest znacząca (np. 1024), pozostałe są przez kompilator ignorowane lub wygenerują błąd kompilacji (zależy to od używanego kompilatora, sprawdź w jego instrukcji).

Zmienna całkowita przechowuje wartości całkowite. Będziemy używać następujących typów całkowitych:

Oprócz tych typów istnieją jeszcze inne, ale teraz nie zaprzątajmy sobie nimi głowy. Pełniejsze zestawienie typów całkowitych znajdziesz tutaj.

Napiszemy teraz program, który wyświetli nam liczbę bajtów pamięci zajmowaną przez zmienną:

// Program 002
// Liczby
// -----------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    // Tworzymy zmienne różnych typów całkowitych

    int a;
    unsigned b;
    long long c;
    unsigned long long d;

    // Wyświetlamy zajętość pamięci przez każdą ze zmiennych

    cout << "int...............: " << sizeof(a) << endl
         << "unsigned..........: " << sizeof(b) << endl
         << "long long.........: " << sizeof(c) << endl
         << "unsigned long long: " << sizeof(d) << endl
         << endl;
    return 0;
}

int...............: 4
unsigned..........: 4
long long.........: 8
unsigned long long: 8

Wykorzystaliśmy tutaj operator sizeof( ), który zwraca rozmiar w bajtach obiektu przekazanego jako argument. Zmienna jest obiektem, który tworzony jest zwykle w pamięci komputera i jako taki zajmuje w niej określoną liczbę komórek (komórka pamięci przechowuje 8 bitów, czyli 1 bajt).

Zmienne całkowite przechowują wartości całkowite. Jeśli chcemy w programie wykonywać działania na wartościach ułamkowych, to tworzymy zmienne zmiennoprzecinkowe wg tych samych reguł, tzn:

typ nazwa_zmiennej;

Typy zmiennoprzecinkowe są następujące:

Typ float jest obecnie rzadko używany, ponieważ oferuje małą dokładność. Jeśli nie będzie wyraźnego powodu, to będziemy zawsze używać typu double. Typ float używano dawniej, gdy komputery miały małą pamięć i należało ją oszczędzać. Typ long double jest typem danych używanych wewnętrznie przez mikroprocesor komputera przy wykonywaniu obliczeń na liczbach zmiennoprzecinkowych. Więcej informacji na ten temat znajdziesz w osobnym artykule.

Napiszemy teraz program wyświetlający liczbę bajtów, które zajmuje w pamięci zmienna danego typu:

// Program 002
// Liczby
// -----------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    // Tworzymy zmienne różnych typów fp

    float x;
    double y;
    long double z;

    // Wyświetlamy zajętość pamięci przez każdą ze zmiennych

    cout << "float......: " << setw(2) << sizeof(x) << endl
         << "double.....: " << setw(2) << sizeof(y) << endl
         << "long double: " << setw(2) << sizeof(z) << endl
         << endl;
    return 0;
}

Wynik:

float......:  4
double.....:  8
long double: 16

W programie użyto manipulatora setw( ), aby ładnie wypozycjonować liczby w kolumnie.

Typ long double w komputerach IBM PC ma faktyczną długość 10 bajtów (80 bitów), jednakże w pamięci jest przechowywany w 16 bajtach, o czym informuje nas operator sizeof. Procesor komputera jest układem dwójkowym i po prostu wygodnie mu operować wielkościami, które w systemie dwójkowym są równymi liczbami:

10(10) = 1010(2)
16(10) = 10000(2)

Do zapamiętania:

• Definicja zmiennej.
• Nazwa zmiennej i jej typ
• Typy całkowite: int, unsigned, long long, unsigned long long.
• Typy zmiennoprzecinkowe float, double, long double
• Operator sizeof( ).

// Program 002
// Zmienne
// -----------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    // Tworzymy zmienne i umieszczamy w nich liczby

    double  r = 16.86;      // promień koła
    double pi = 3.141592; // liczba pi

    // Wyświetlamy zawartość zmiennych

    cout << "Obwód i pole koła" << endl
         << "-----------------" << endl << endl
         << "r = " << r << endl << endl;

    return 0;
}

Program nie jest jeszcze skończony, ale pokazuje sposób użycia operatora przypisania:

zmienna = wyrażenie;

Nie oznacza to równości w sensie matematycznym. Komputer najpierw wylicza wartość wyrażenia i wynik wprowadza do zmiennej. W wyrażeniu można stosować operatory arytmetyczne:

+

dodawanie

-

odejmowanie

*

mnożenie

/

dzielenie

Jest to tzw. instrukcja przypisania (ang. assignment statement). Występuje praktycznie w każdym programie C++.

Dokończmy nasz program:

// Program 002
// Zmienne
// -----------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    // Tworzymy zmienne i umieszczamy w nich liczby

    double  r = 16.86;    // promień koła
    double pi = 3.141592; // liczba pi

    // Wyświetlamy zawartość zmiennych

    cout << "Obwód i pole koła" << endl
         << "-----------------" << endl << endl
         << "r = " << r << endl << endl;

    // Wykonujemy obliczenia

    double obw  = 2 * pi * r;
    double pole = pi * r * r;

    cout << "o = " << obw << endl
         << "p = " << pole << endl << endl;

    return 0;
}

Obwód i pole koła
-----------------

r = 16.86

o = 105.934
p = 893.028

Komputer wyliczył pole i obwód koła, umieścił wynik obliczeń w zmiennych obw i pole, po czym przesłał do strumienia cout wartości tych zmiennych. Postaraj się samodzielnie sformatować wyświetlanie liczb w oknie konsoli przy pomocy manipulatorów.

Nazwa zmienna (ang. variable) pochodzi stąd, iż może ona zmieniać swoją zawartość. Na przykładzie tego prostego programu pokażę, jak to może wyglądać. Załóżmy, że chcemy jako wynik używać tylko jednej zmiennej o nazwie x.

// Program 002
// Zmienne
// -----------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    // Tworzymy zmienne i umieszczamy w nich liczby

    double  r = 16.86;      // promień koła
    double pi = 3.141592; // liczba pi

    // Wyświetlamy zawartość zmiennych

    cout << "Obwód i pole koła" << endl
         << "-----------------" << endl << endl
         << "r = " << r << endl << endl;

    double x; // Tworzymy zmienną na wyniki

    x = 2 * pi * r; // liczymy obwód koła

    cout << "o = " << x << endl;

    x = pi * r * r; // liczymy pole

    cout << "p = " << x << endl << endl;

    return 0;
}

Jak widzisz, zmienna raz utworzona w programie może być wielokrotnie zmieniana. Zmienna jest jakby pojemnikiem, do którego wprowadzamy informację, a zmienna przechowuje tę informację do momentu aż wprowadzimy do niej inną.

O operatorze przypisania pomówimy jeszcze wiele razy.

Do zapamiętania:

• Operator przypisania.
• Instrukcja przypisania.
• Operatory arytmetyczne.

Jeśli w wyrażeniu spotka się kilka operatorów, to będą one wykonane w kolejności od strony lewej do prawej:

* /
+ -

Czyli najpierw komputer wyliczy mnożenia i dzielenia, a następnie ich wyniki zostaną dodane lub odjęte zgodnie z operatorami dodawania/odejmowania. Na przykład wyrażenie:

2 * 3 + 2 * 2

da wynik 10. Komputer najpierw wyliczy wyniki mnożeń: 2 * 3 = 6 oraz 2 * 2 = 4, a następnie je doda: 6 + 4 = 10. Jest to zgodne z kolejnością działań w arytmetyce.

Jeśli chcemy zmienić kolejność wykonywania działań, to stosujemy nawiasy. Wyrażenia w nawiasach są wyliczane najpierw. Na przykład:

2 * (3 + 2 ) * 3

da wynik 30, ponieważ komputer najpierw wykona dodawanie (3 + 2) = 5, następnie wykona mnożenia: 2 * 5 = 10 i 10 * 3 = 30.

W matematyce stosuje się różne nawiasy, na przykład:

W języku C++ w tym charakterze używane są tylko nawiasy okrągłe:

(5 * (7 + (3 / 2))) - 6

Operatory +, - i * nie sprawiają problemów, natomiast operator dzielenia / może je sprawić, jeśli nie znasz sposobu jego działania. Wpisz do edytora Code::Blocks program, skompiluj go i uruchom:

#include <iostream>

using namespace std;

int main()
{
    cout << 5 / 4 * 20 << endl;

    return 0;
}

W wyniku otrzymaliśmy liczbę 20. Dlaczego? Otóż operator / daje wynik całkowity, jeśli oba argumenty (lewy i prawy) są całkowite. Wtedy 5 / 4 = 1, bo 4 mieści się w 5 jeden raz i zostaje reszta 1. Dlatego 5 / 4 = 1 i później 1 * 20 = 20.

Jeśli chcemy, aby operator dzielenia dawał wynik ułamkowy, to musimy zapewnić, iż jeden z argumentów jest liczbą fp (ang. floating point = zmiennoprzecinkową). Najprościej dopisać kropkę. Zmień wiersz z cout na:

cout << 5. / 4 * 20 << endl;

lub na:

cout << 5 / 4. * 20 << endl;

albo na:

cout << 5. / 4. * 20 << endl;

Kropka w zapisie liczby oznacza liczbę zmiennoprzecinkową (inny sposób kodowania bitów, pamiętasz?). Jeśli za kropką nie wpiszesz cyfr, to komputer potraktuję to jako część ułamkową równą zero, czyli liczba jest całkowita, ale zostaje zakodowana w pamięci jako zmiennoprzecinkowa.

Co zrobić, jeśli musimy podzielić zmienne całkowite, a nie chcemy wyniku całkowitoliczbowego?

Wpisz do edytora poniższy program, skompiluj i uruchom go:

#include <iostream>

using namespace std;

int main()
{
    int a = 5, b = 4, c = 20;

    cout << a / b * c << endl;

    return 0;
}

W programie tworzymy trzy zmienne całkowite o nazwach a, b i c. Nadajemy im wartości początkowe operatorami przypisania. Zwróć uwagę, iż w jednym wierszu można zdefiniować wiele zmiennych, oddzielając je przecinkami:

typ zmienna_1, zmienna_2, ..., zmienna_n;

Do strumienia wysyłamy wartość identycznego wyrażenia jak w poprzednim programie, tylko tym razem zamiast liczb są zmienne. Otrzymujemy 20, ponieważ w pierwszym dzieleniu oba argumenty a i b są całkowite, zatem a / b = 1 i reszta 1, a następnie 1 * c = 20.

Jeśli chcemy otrzymać wynik ułamkowy, musimy typ dowolnego z argumentów zmienić w typ zmiennoprzecinkowy. W języku C++ uzyskuje się to przez tzw. rzutowanie (ang. casting). Zmieniany argument poprzedzamy nawiasami, w których umieszczamy nazwę typu docelowego. Zmień wiersz w programie na:

cout << (double) a / b * c << endl;

Lub na:

cout << a / (double) b * c << endl;

Rzutowanie nie zmienia typu zmiennej (zmienna a dalej pozostaje zmienną całkowitą int). Zmienia jedynie typ jej wartości w danym wyrażeniu, dzięki temu operator dzielenia da wynik ułamkowy, a nie całkowity.

W tym konkretnym przypadku możemy dojść do tego samego wyniku przez reorganizację wyrażenia:

cout << a * c / b << endl;

Co to daje? Komputer najpierw pomnoży a * c = 100. Teraz podzielenie da 100 / b = 25. Jednak nie zawsze da się tak zrobić, dlatego pamiętaj o rzutowaniu.

Do zapamiętania:

• Kolejność operacji arytmetycznych * / + -.
• Podwyrażenie w nawiasach liczone najpierw.
• Operator dzielenia i jego własności.
• Zmiana liczby całkowitej w liczbę fp przez dodanie kropki.
• Rzutowanie na inny typ wartości.

cout (ang. console output = wyjście konsoli; czytaj si ałt bez zmiękczania s jak w słowie sinus), który umożliwia przesyłanie informacji do okna konsoli:
cout << informacja;

cin (ang. console input = wejście konsoli; czytaj si in bez zmiękczania s), który pozwala odczytywać informację wprowadzoną do konsoli przez użytkownika za pomocą klawiatury:
cin >> zmienna;

Zwróć uwagę, iż informację odczytujemy operatorem odczytu ze strumienia >>, który ma odwrotny zwrot do operatora zapisu do strumienia <<. Odczytana informacja trafia do wybranej zmiennej. Wpisz do edytora Code::Blocks poniższy program, skompiluj go i uruchom:

// Program 002
// Odczyt do zmiennej
//-------------------

#include <iostream>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    int wiek;

    cout << "Witaj, ile masz lat? : ";

    cin >> wiek; // Odczyt z konsoli

    cout << endl
         << "Masz " << wiek << " lat." << endl
         << "Ale za 50 lat będziesz ich miał "
         << wiek + 50 << endl << endl;

    return 0;
}

Przykładowy wynik tego programu:

Witaj, ile masz lat? : 17

Masz 17 lat.
Ale za 50 lat będziesz ich miał 67

Możesz teraz stworzyć typowy program obliczeniowy wg schematu:

Napiszmy prosty program, który przeliczy temperaturę w stopniach Celsjusza na temperaturę w stopniach Fahrenheita. Wzór przeliczeniowy jest następujący:

Uwaga: dzielenie 9/5 zostanie wykonane jako całkowitoliczbowe i otrzymamy wynik 1. Należy zatem przekształcić w programie jedną z tych liczb na liczbę fp.

// Program 002
// Przykład obliczeniowy
//----------------------

#include <iostream>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    int tc,tf;

    cout << "Przeliczanie °C na °F" << endl
         << "---------------------" << endl << endl
         << "Temperatura °C = ";

    cin >> tc;

    tf = 9. / 5 * tc + 32; // 9 na fp!!!

    cout << "Temperatura °F = " << tf << endl << endl;

    return 0;
}

Do zapamiętania:

• Strumień wyjścia konsoli (cout) i strumień wejścia konsoli (cin).
• Operator przesłania do strumienia (<<) i operator odczytu ze strumienia (>>).
• Program typu obliczeniowego.

Modyfikacja zmiennej polega na zmianie jej zawartości, ale operacja ta wykorzystuje bieżącą zawartość zmiennej. Na przykład chcemy zwiększyć wartość w zmiennej o 1. Możemy użyć operatora przypisania:

a = a + 1;

Działa to w ten sposób, iż komputer wylicza wartość wyrażenia po prawej stronie operatora =, czyli bierze bieżącą zawartość zmiennej, dodaje do niej 1 i wynik umieszcza z powrotem w zmiennej po lewej stronie operatora =. W efekcie zawartość zmiennej zostaje zwiększona o 1. Wpisz do edytora poniższy program, skompiluj go i uruchom:

// Program 002
// Modyfikacja zmiennej
//---------------------

#include <iostream>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    int a = 5;

    cout << "Przed modyfikacją" << endl
         << "a = " << a << endl << endl;

    a = a + 1;

    cout << "Po modyfikacji" << endl
         << "a = " << a << endl << endl;

    return 0;
}

Otrzymasz następujący wynik:

Przed modyfikacją
a = 5

Po modyfikacji
a = 6

W ten sposób możemy zmodyfikować dowolnie zmienną. Ponieważ zwiększanie o 1 i zmniejszanie o 1 są operacjami intensywnie wykorzystywanymi w programowaniu, w języku C++ mamy specjalne operatory zwiększania ++ i zmniejszania --.

Zmodyfikuj program:

// Program 002
// Modyfikacja zmiennej
//---------------------


#include <iostream>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    int a = 5;

    cout << "Przed modyfikacją" << endl
         << "a = " << a << endl << endl;

    a++;

    cout << "Po modyfikacji" << endl
         << "a = " << a << endl << endl;

    return 0;
}

Teraz zmień program następująco (po każdej zmianie skompiluj go i uruchom):

• zmień pozycję operatora ++ tak, aby znalazł się przed zmienną: ++a;
• zamiast operatora ++ użyj operatora --, który odejmuje od zmiennej 1.

Jak widzisz, operator zwiększania o 1 ++ (lub zmniejszania o 1 --) może znaleźć się przed jak i za zmienną. Czy jest jakaś różnica? Jeśli operacja modyfikacji jest samodzielna (jak w naszym programie), to nieważne jest, czy umieścisz ten operator przed lub za zmienną. Inaczej będzie jednak w wyrażeniu.

Zmień program na następujący:

// Program 002
// Modyfikacja zmiennej
//---------------------


#include <iostream>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    int a = 5, b;

    cout << "Przed modyfikacją" << endl
         << "a = " << a << endl << endl;

    b = a++;

    cout << "Po modyfikacji" << endl
         << "a = " << a << endl
         << "b = " << b << endl << endl;

    return 0;
}

Uruchom program. Otrzymasz:

Przed modyfikacją
a = 5

Po modyfikacji
a = 6
b = 5

Zmienna a została zwiększona o 1, bo tak działa operator ++. Zwróć jednak uwagę na zmienną b, do której trafiła oryginalna zawartość zmiennej a (jeszcze nie zmodyfikowana). Wynika z tego wniosek, że w wyrażeniu zmienna++ ma wartość zmiennej przed modyfikacją. Zmienna jest modyfikowana później, po zakończeniu wyliczania całego wyrażenia.

Zmień instrukcję b = a++; na b = ++a;. Skompiluj i uruchom program. Teraz wynik będzie następujący:

Przed modyfikacją
a = 5

Po modyfikacji
a = 6
b = 6

Do zmiennej b trafiła wartość zmodyfikowana zmiennej a. Zatem modyfikacja została wykonana przed wyliczeniem wyrażenia. Tak samo zachowuje się operator --. Mnemotechnicznie zapamiętujemy to tak:

Przesuwamy się po wyrażeniu od strony lewej do prawej. Jeśli trafimy najpierw na zmienną, to w wyrażeniu zmienna nie jest jeszcze zmodyfikowana:

→ zmienna++

Jeśli natrafimy najpierw na operator ++ (lub --), to w wyrażeniu zmienna jest już zmodyfikowana:

→ ++zmienna

Do zapamiętania:

• Na czym polega modyfikacja zmiennej?
• Operatory ++ i -- w instrukcji oraz w wyrażeniu.