Taśma filmowa z kodem programu

Gdy liczba instrukcji maszyny cyfrowej rosła, a same instrukcje stawały się coraz bardziej skomplikowane, wymyślono język asemblera (ang. assembler language). Zamiast binarnych kodów instrukcji w języku asemblera stosuje się ich nazwy symboliczne (jak ADD, SUB, JMP). Dzięki temu łatwiej je zapamiętać, a i sam program staje się dużo prostszy.

START: LDA #"Z
LOOP:  STA $INOUT
       DEC
       JMP #LOOP
       END

0001010001011010
0010100000000000
1001000000000000
1010010000000010
0000000000000000

Procesor rozumie tylko i wyłącznie swój kod binarny. Dlatego tworząc programy w asemblerze musimy je kompilować, czyli zamieniać na postać binarną. Konwersji takiej dokonuje program, który również nazywamy asemblerem. Pierwszy asembler musiał jednak być napisany bezpośrednio w kodzie binarnym.

Asembler daje programiście dostęp do wszystkich składników komputera. Jednakże tworzenie programu jest bardzo żmudne, ponieważ każdą operację należy rozbijać na poszczególne instrukcje procesora. Np. sprawdzenie, czy komórki o etykietach L1 i L2 są sobie równe, wymaga kilku instrukcji procesora:

LDA $L1    ; załaduj do akumulatora komórkę L1
SUB $L2    ; odejmij od niej komórkę L2
JZR #ROWNE ; jeśli są równe, skocz
...        ; jeśli są różne, jesteś tutaj

Czyż nie byłoby lepiej zapisać:

JEŚLI L1 = L2, TO ...
INACZEJ ...

I tak dochodzimy do koncepcji języków wysokiego poziomu – HLL (ang. High Level Language). Asembler, a tym bardziej kod binarny instrukcji procesora, to języki niskiego poziomu – LLL (ang. Low Level Language), które operują bezpośrednio na zasobach komputera: na procesorze, pamięci, rejestrach wejścia/wyjścia. Aby w nich efektywnie programować, programista musi posiadać dużą wiedzę na temat budowy komputera oraz urządzeń towarzyszących. Również musi dokładnie wiedzieć, w jaki sposób realizować złożone polecenia. Pomyłki w kodzie są trudne do wyłapania. Wszystko to powoduje, że chociaż asembler jest bardzo potężnym narzędziem, to jednak jest również bardzo trudny w opanowaniu i mało efektywny przy dużych projektach. Dzisiaj w asemblerze tworzone są tylko fragmenty programów, które muszą być naprawdę szybkie i efektywne.

Język wysokiego poziomu oddala się od sprzętu komputera i pozwala tworzyć bardziej abstrakcyjne konstrukcje, które zbliżone są do pojęć matematycznych. Dzięki temu programista może dużo szybciej tworzyć złożone programy, niż jest to możliwe w asemblerze. Wszystkie języki wysokiego poziomu muszą być przetwarzane na postać binarną (nie dotyczy to języków interpretowanych, tzw. skryptowych, o których dowiemy się później). Konwersję taką wykonuje program zwany kompilatorem (ang. compiler).

Pierwsze języki wysokiego poziomu zaczęły się pojawiać po II Wojnie Światowej. Wcześniej stosowano kody binarne oraz asemblery. Poniżej podajemy chronologiczną listę najważniejszych języków programowania (niech cię nie przeraża ich liczba, i tak nie są to wszystkie języki programowania):

• 1952 - Autokod
• 1954 - IPL (poprzednik języka LISP)
• 1955 - FLOW-MATIC (poprzednik języka COBOL)
• 1957 - FORTRAN (pierwszy kompilator)
• 1957 - COMTRAN (poprzednik języka COBOL)
• 1958 - LISP
• 1958 - ALGOL 58
• 1959 - FACT (poprzednik języka COBOL)
• 1959 - COBOL
• 1959 - RPG
• 1962 - APL
• 1962 - Simula
• 1962 - SNOBOL
• 1963 - CPL (poprzednik języka C)
• 1964 - BASIC
• 1964 - PL/I
• 1966 - JOSS
• 1967 - BCPL (poprzednik języka C)
• 1968 - Logo
• 1969 - B (poprzednik języka C)
• 1970 - Pascal
• 1970 - Forth
• 1972 - C
• 1972 - Smalltalk
• 1972 - Prolog
• 1973 - ML
• 1975 - Scheme
• 1978 - SQL (początkowo jedynie język zapytań do bazy danych, później rozbudowany o instrukcje programowania)
• 1980 - C++ (jako C z klasami, nazwa zmieniona w lipcu 1983)
• 1983 - Ada
• 1984 - Common Lisp
• 1984 - MATLAB
• 1985 - Eiffel
• 1986 - Objective-C, kurs Objective-C
• 1986 - Erlang
• 1987 - Perl
• 1988 - Tcl
• 1988 - Mathematica
• 1989 - FL (Backus);
• 1990 - Haskell
• 1991 - Python
• 1991 - Visual Basic
• 1993 - Ruby
• 1993 - Lua
• 1994 - CLOS (część języka ANSI Common Lisp)
• 1995 - Java
• 1995 - Delphi (Object Pascal)
• 1995 - JavaScript
• 1995 - PHP
• 1996 - WebDNA
• 1997 - Rebol
• 1999 - D
• 2000 - ActionScript
• 2001 - C#
• 2001 - Visual Basic .NET
• 2002 - F#
• 2003 - Groovy
• 2003 - Scala
• 2007 - Clojure
• 2009 - Go
• 2011 - Dart

Język C++ jest językiem programowania stworzonym przez Bjarne Stroustrupa, profesora Texas A&M University. Jest to język wysokiego poziomu i należy do grupy języków kompilowanych. Oznacza to, iż programista w edytorze tworzy tekst programu, który następnie jest przekazywany do kompilatora. Kompilator analizuje otrzymany tekst i na jego podstawie tworzy program wynikowy zawierający binarne instrukcje dla procesora.

Języki wysokiego poziomu są bardziej czytelne dla ludzi. Jednakże procesor nie potrafi bezpośrednio wykonywać zawartych w takim programie poleceń - program musi być przetłumaczony do postaci zrozumiałej dla procesora, czyli do binarnych kodów instrukcji maszynowych.

Do programowania w języku C++ będziemy używali zintegrowanego środowiska programowania (ang. IDE - Integrated Developement Environment), które zawiera edytor oraz kompilator. Na lekcjach oprzemy się o darmowe środowisko Code::Blocks oraz o pakiet Borland C++ Builder 6.0 Personal Edition, które można pobrać z sieci Internet. Na komputerze domowym ucznia musi być bezwzględnie zainstalowane podane środowisko programowania, aby mógł wykonywać ćwiczenia w domu.

Poniższy opis dotyczy instalacji CodeBlocs 16.01 w systemie Windows 10. Dla innych systemów Windows instalacja jest praktycznie identyczna.

Pobranie instalatora

Przejdź do strony:

Wybierz opcję:

Spowoduje to przejście do strony pobierania aplikacji. U samej góry wybierz swój system operacyjny, mianowicie Windows XP / Vista / 7 / 8.x / 10.  Dla systemu Windows dostępne jest kilka wersji instalatora.  Code::Blocks. Dla naszych potrzeb należy wybrać instalator z kompilatorem MingW. W przypadku wersji 16.01 będzie to plik o nazwie codeblocks-16.01mingw-setup.exe. Po prawej stronie wybierz źródło ładowania: Sourceforge.net. Przejdziesz w ten sposób do witryny Sourceforge, z zostanie automatycznie załadowany instalator Code::Blocks. Jeśli twoją przeglądarką sieci jest Firefox, to pojawi się okienko:

W oknie wybierz przycisk Zapisz plik. Plik zostanie pobrany i zapisany na twoim dysku w katalogu przeznaczonym na odczytane z sieci pliki (zależy on od ustawień przeglądarki Firefox).

Instalacja

Uruchom instalator. Zaczną się pojawiać kolejne okienka dialogowe instalacji. Poniżej masz przetłumaczoną ich treść. Jest to typowy proces instalacyjny i, jeśli nie masz jakiś specjalnych powodów, to po prostu zatwierdzaj je klikając na przycisk Next.

	Witaj w Programie Instalacyjnym Code::Blocks   Program instalacyjny poprowadzi cię poprzez instalację Code::Blocks. Zalecane jest zamknięcie wszystkich innych aplikacji przed uruchomieniem instalacji. Pozwoli to uaktualnić istotne pliki systemowe bez potrzeby ponownego uruchomienia komputera. Aby kontynuować, kliknij na Dalej.   Dalej >    Anuluj
	Zgoda licencyjna Proszę przeglądnąć warunki licencji przed instalacją Code::Blocks. Naciśnij klawisz PgDn, aby zobaczyć resztę zgody licencyjnej. [Treść licencji GNU] Jeśli zgadzasz się na warunki zgody licencyjnej, kliknij przycisk Zgadzam się. Musisz zaakceptować zgodę licencyjną, aby zainstalować Code::Blocks.   < Wstecz     Zgadzam się    Anuluj
	Wybierz Składniki Wybierz, które cechy Code::Blocks chcesz zainstalować. Zaznacz składniki, które chcesz zainstalować, a skazuj zaznaczenie dla tych, których nie chcesz instalować. Kliknij Dalej, aby kontynuować. Wybierz rodzaj instalacji: Pełna instalacja: wszystkie wtyczki, wszystkie narzędzia, po prostu wszystko Lub wybierz opcjonalne składniki, które chcesz zainstalować   [ Drzewo składników] Wymagane miejsce: 229,6MB Opis Umieść kursor myszki ponad składnikiem, aby zobaczyć jego opis   < Wstecz     Dalej >    Anuluj
	Wybierz Miejsce Instalacji Wybierz katalog, w którym zostanie zainstalowane Code::Blocks. Program instalacyjny zainstaluje Code::Blocks w następującym katalogu. Aby zainstalować w innym, kliknij przycisk Przeglądaj... i wybierz inny katalog. Kliknij przycisk Instaluj, aby rozpocząć instalację. Katalog Docelowy [C:\Program Files (x86)\Code::Blocks ] [ Przeglądaj... ] Wymagane miejsce: 229,6MB Dostępne miejsce: 749,6GB   < Wstecz     Instaluj >    Anuluj
	Instalowanie Proszę poczekać w trakcie instalacji Code::Blocks.   < Wstecz     Dalej >    Anuluj
	Instalacja Zakończona Instalacja zakończyła się sukcesem.   < Wstecz     Dalej >    Anuluj
	Kończenie Instalacji Code::Blocks   Code::Blocks zostało zainstalowane na twoim komputerze. Kliknij przycisk Zakończ, aby zakończyć program instalacyjny.   < Wstecz     Zakończ >    Anuluj

Uruchomienie i test instalacji

Uruchom Code::Blocks (Launcher). Przy pierwszym uruchomieniu Code::Blocks musi wybrać kompilator, który będzie używany do kompilacji programów. Jeśli wybrałeś instalację z MIngW, to kompilator taki został zainstalowany wraz z Code::Blocks. W oknie automatycznego wykrywania zainstalowanych kompilatorów, które się pojawi, zaznacz GNU GCC Compiler i kliknij w przycisk Set as default (ustaw jako standardowy).

Kliknij w przycisk OK. Przed uruchomieniem IDE aplikacja wyświetli następujące okno dialogowe:

Ustawia się tutaj skojarzenia plików źródłowych C i C++ ze środowiskiem Code::Blocks. Pozostaw okienko bez zmian, chyba że dokładnie wiesz co i dlaczego robisz. Kliknij przycisk OK. Pojawi się okno startowe.

Na ekranie startowym zobaczysz opcję Create a new project (Utwórz nowy projekt). Kliknij ją lewym przyciskiem myszki. Zostanie otwarte okienko dialogowe wyboru typu projektu:

Wybierz opcję Console application (Aplikacja konsoli).

Co to jest aplikacja konsoli? Kiedyś, dawno temu, gdy jeszcze nie powstał system Windows, komputery programowane były w systemie DOS w trybie znakowym. Ekran wyświetlał ustalony zestaw znaków. Tryb ten pojawia się czasem na niektórych starszych komputerach IBM-PC przy starcie systemu, zanim Windows/Linux przejmą kontrolę. Ekran w trybie tekstowym wyglądał tak:

Na dzisiejszych komputerach tryb ten stał się już przestrzały, jednak wciąż możemy go symulować w Windows oraz w Linuxie. Zaletą konsoli jest prostota używania. Nie musisz walczyć z procedurami graficznymi Windows, aby wyświetlić wynik działania swojego programu: po prostu przesyłasz do konsoli tekst, a ten zostanie pokazany. Gdy będziesz programował mikrokontrolery, to nawet taka prosta konsola nie będzie dostępna. Ale o tym później.

Gdy wybierzesz aplikację konsoli, to twój program otrzyma możliwość wysyłania tekstu do konsoli oraz odczytywania informacji, którą użytkownik wprowadził z klawiatury.

Zatwierdź wybór w oknie dialogowym przez kliknięcie w przycisk Go. Pojawi się następne okno dialogowe z wyborem języka projektu:

Zaznaczasz C++ i klikasz w przycisk Next. Pojawi się następne okno dialogowe, które jest bardzo ważne.

W polu Project title (nazwa projektu) wpisz wybraną przez siebie nazwę dla projektu. Nazwę tę otrzyma również program wynikowy. Dla prostoty będziemy sobie projekty kolejno numerować. Ten jest pierwszy, wpisz zatem nazwę p01 (projekt nr 1).

W polu Folder to create peroject in (katalog dla projektu) należy wpisać ścieżkę do katalogu, który utworzyłeś na swoje projekty. Nauczyciel poda ci, co należy tutaj wpisać. Nie kieruj się zawartością tego pola na powyższym obrazku, ponieważ to odnosi się do mojego prywatnego komputera, na którym przygotowuję ten artykuł. Jeśli nie pamiętasz ścieżki do katalogu, w którym ma zostać utworzony projekt, to kliknij lewym przyciskiem myszki przycisk z trójkropkiem, a następnie wybierz odpowiedni katalog.

Pozostałych pól nie zmieniaj, ponieważ Code::Blocks zarządza nimi automatycznie:

Project filename (nazwa pliku projektu) określa nazwę pliku, w którym środowisko zapisuje informacje o twoim programie. Plik projektu posiada standardowo taką samą nazwę jak ta w pierwszym polu i rozszerzenie cbp (Code::Blocks project).

Resulting filename (wynikowa nazwa pliku) Code::Blocks dla każdego projektu tworzy osobny katalog o nazwie takiej samej, jaką ma projekt – dzięki temu pliki nie będą się mieszały w różnych projektach. Katalog ten jest umieszczany w katalogu, którego ścieżkę dostępu umieścisz w drugim polu. Do katalogu projektu trafia plik projektu i tutaj możemy zobaczyć pełną ścieżkę dostępu do tego pliku.

Kliknij w przycisk Next. Pojawi się ostatnie okno dialogowe:

W tym oknie określa się sposób generacji programu wynikowego. Konfiguracją wybraną jest tryb Debug (uruchomieniowy). W tym trybie kompilator umieszcza w kodzie programu dodatkowe informacje, które programista może wykorzystać do śledzenia wykonania programu i wyłapywania błędów. Kod jest przez to dłuższy i może działać nieco wolniej. Tryb Release (wydawniczy) jest używany, gdy program został już uruchomiony i nie zawiera błędów. Nas to nie dotyczy, ponieważ będziemy pisać bardzo proste programy. Nic tu nie zmieniaj, kliknij przycisk Finish.

Środowisko utworzy projekt programu. Na bocznym panelu Management (zarządzanie – jeśli panel jest niewidoczny, wciśnij Shift+F2)  rozwiń drzewko projektu i kliknij dwukrotnie w plik main.cpp.

Spowoduje to załadowanie pliku do edytora. Czcionkę w edytorze możesz szybko powiększać lub pomniejszać wciskając Ctrl i kręcąc kółkiem myszki lub naciskając klawisze + - na klawiaturze numerycznej.

Ponieważ rozpoczynasz naukę języka C++, usuń wszystko z edytora i wprowadź poniższy kod.

int main()
{

}

Program w języku C++ zbudowany jest z tzw. funkcji, czyli fragmentów kodu, które można wielokrotnie używać. Najprostszy program posiada tylko jedną funkcję, która nosi nazwę main (główna). Nazwa ta musi być pisana małymi literami, ponieważ język C++ rozróżnia duże i małe litery. Wykonanie programu w języku C++ zawsze rozpoczyna się od kodu w funkcji main, dlatego jest to główna funkcja programu.

Powyższy program zawiera pustą funkcję main, czyli po prostu nic nie robi, lecz można go skompilować i uruchomić, a o to nam w tym momencie chodzi.

Aby skompilować program (czyli utworzyć na dysku plik programu z rozszerzeniem exe), kliknij myszką na ikonę (na pasku narzędziowym u góry okna):

lub naciśnij klawisze Ctrl+F9.

Tekst programu zostanie przekazany do kompilatora, który zamieni go w program uruchamialny o rozszerzeniu exe. Postęp kompilacji możesz obserwować na dolnym panelu – jeśli jest niewidoczny, naciśnij klawisz F2. Pojawi się tam następujący tekst:

W tym momencie interesuje cię tylko ostatni tekst, w którym pojawi się informacja o wykrytych błędach (errors) i ostrzeżeniach (warnings) oraz o czasie kompilacji. Jeśli w programie znajdą się błędy, to nie powstanie program uruchamialny.

Gdy kompilacja przebiegnie bez błędów, to będziesz mógł uruchomić swój program. Można to zrobić z poziomu Windows lub z poziomu środowiska Code::Blocks. Na lekcjach będziemy korzystali najczęściej z tego drugiego sposobu. Aby uruchomić program, myszką na ikonę (na pasku narzędziowym u góry okna):

Program zostanie uruchomiony i na ekranie pojawi się okno konsoli, w którym będzie wyświetlony napis:

Napis ten pochodzi nie z programu (bo nasz program przecież nic nie robi), lecz ze środowiska Code::Blocks. Informuje cię ono, że program zakończył działanie, zwracając kod 0 (w nawiasie jest podana wartość szesnastkowa tego kodu), a czas wykonania wyniósł 0,047s. Gdy naciśniesz jakiś klawisz (najlepiej ESC), okno konsoli zostanie zamknięte i powrócisz do edytora.

Funkcja main() zwraca wartość całkowitą, którą można wykorzystać (i często to się robi) do przekazania dodatkowych informacji przez program - np. czy wykonanie powiodło się, czy też wystąpił jakiś błąd. Do zwracania wartości przez funkcję używamy polecenia return. Jeśli je pominiesz, to funkcja zwróci zero. Zmień program w edytorze na poniższy:

int main()
{
    return 155;
}

Instrukcję języka C++ kończy się za pomocą średnika. Dlatego po liczbie 155 mamy średnik.

Jeśli teraz skompilujesz i uruchomisz program, w oknie konsoli pojawi się informacja:

Instrukcja return kończy działanie funkcji. Ponieważ jest to ostatnia instrukcja w naszym programie, jej wykonanie powoduje zwrócenie odpowiedniego kodu i zakończenie działania programu.

Zwykle program w C++ musi odczytywać dane z konsoli i wyprowadzać na nią wyniki swojego działania. Operacje wejścia/wyjścia nie są częścią definicji języka C++, lecz osobną biblioteką. Jeśli chcemy z nich korzystać, to musimy poinformować kompilator o obiektach, które tych operacji dokonują. Definicje obiektów zawarte są w tzw. plikach nagłówkowych (ang. header files), które dołączamy do programu dyrektywą #include. Wpisz poniższy program:

#include <iostream>

int main()
{
    return 0;
}

Pliki nagłówkowe są bardzo wygodnym rozwiązaniem - zamiast w każdym programie wpisywać żmudnie definicje tych samych obiektów, wpisujemy jedynie prostą dyrektywę. Przed rozpoczęciem kompilacji plik źródłowy jest wstępnie obrabiany przez tzw. preprocesor. Wyszukuje on w programie źródłowym swoich poleceń, które nazywamy dyrektywami preprocesora. Np. polecenie #include każe preprocesorowi zastąpić się zawartością odpowiedniego pliku nagłówkowego, który jest wstawiany w miejscu tej dyrektywy. Następnie tak zmieniony plik wędruje do kompilatora, który ma już pod ręką wszystkie potrzebne definicje.

Plik nagłówkowy iostream definiuje tzw. strumienie wejścia/wyjścia konsoli (ang. input output streams). Strumień wyjścia cout (ang. console output) pozwala wyświetlać informację w oknie konsoli. Strumień wejścia cin (ang. console input) z kolei pozwala odczytywać informację wpisaną przez użytkownika z klawiatury. Wpisz poniższy program:

#include <iostream>

int main()
{
    std::cout << "Witaj. Jestem twoim programem w C++" << std::endl;
    return 0;
}

Po uruchomieniu zobaczymy w oknie konsoli napis:

<< jest operatorem przesłania danych do strumienia.

endl to tzw. manipulator powodujący przejście z wydrukiem do następnego wiersza w oknie konsoli. Dzięki niemu po napisie Jestem twoim programem w C++ mamy jeden pusty wiersz odstępu. Zamiast manipulatora endl można w tekście umieszczać znaki końca wiersza - \n:

#include <iostream>

int main()
{
    std::cout << "Witaj. Jestem twoim programem w C++\n"
                 "-----------------------------------\n\n";
    return 0;
}

Zauważ, że na końcu pierwszego tekstu nie dodajemy średnika, ponieważ instrukcja nie jest tutaj jeszcze zakończona. Po prostu kontynuujemy przesyłanie dalszej części tekstu w drugim wierszu.

Nazwy cout oraz endl są poprzedzone napisem std::. Jeśli go usuniesz, to program nie da się skompilować, ponieważ kompilator nie potrafi odnaleźć cout i endl. Napis std to tzw. przestrzeń nazw, w której żyją obiekty biblioteki STL. Wyobraź sobie ją jako worek z napisem std. Poza tym workiem nazwy zdefiniowanych w nim obiektów są niedostępne, o ile nie poprzedzisz je napisem std:: - wtedy kompilator będzie po prostu wiedział, gdzie ich szukać. Możesz jednakże poinformować kompilator, że chcesz standardowo korzystać z danej przestrzeni nazw - do tego celu służy dyrektywa using namespace, za którą wpisujemy nazwę przestrzeni nazw. Gdy taką dyrektywę umieścisz w swoim programie, to nie będziesz musiał poprzedzać nazw cout, cin i innych z STL kwalifikatorem std:: - do duże ułatwienie. Dyrektywa using namespace std mówi po prostu kompilatorowi, że jeśli nie znajdzie danej nazwy w standardowym środowisku, to ma jej poszukać w "worku" o nazwie std. Przestrzenie nazw zmniejszają ryzyko konfliktów nazw różnych obiektów i z tego powodu znalazły się w języku C++. Uwierz nam, to dobry wynalazek.

Wpisz poniższy program:

#include <iostream>

using namespace std;

int main()
{
    cout << "Witaj. Jestem twoim programem w C++" << endl
         << "-----------------------------------" << endl << endl;
    return 0;
}

Na początku programu umieszczamy zwykle krótki komentarz informujący użytkownika o przeznaczeniu danego programu, autorze i dacie utworzenia. Komentarze mamy za darmo - nie są one przenoszone do programu wynikowego i w żaden sposób nie zwiększają jego pojemności ani nie zmniejszają szybkości działania. Komentujmy zatem programy - staną się o wiele czytelniejsze nawet dla samych ich autorów - szczególnie po upływie kilku tygodni od daty utworzenia.

// Przykładowy program w języku C++
// (C)2017 I LO w Tarnowie
//---------------------------------

#include <iostream>

using namespace std;

int main()
{
    cout << "Witaj. Jestem twoim programem w C++" << endl
         << "-----------------------------------" << endl << endl;
    return 0;
}

Podsumowanie

Program w języku C++ posiada następującą strukturę:

// Przykładowy program w języku C++
// (C)2015 I LO w Tarnowie
//---------------------------------

#include <iostream>

using namespace std;

int main()
{
    cout << "Cześć. Jestem twoim programem w języku C++" << endl
         << "------------------------------------------" << endl << endl;
    return 0;
}

Przykłady deklaracji zmiennych:

int a;                    // zmienna a jest zmienną U2

int a,b,c,d;              // w jednej definicji można umieścić kilka zmiennych

unsigned int x1,x2,wynik; // zmienne NBC

Często informacja jest wprowadzana do zmiennych z klawiatury komputera. W ten sposób użytkownik może podać dane, które komputer następnie przetworzy w programie. Odczytu danych z klawiatury dokonujemy w języku C++ przy pomocy strumienia cin (ang. console input – wejście konsoli). Składnia jest następująca

cin >> nazwa_zmiennej;

W jednym rozkazie można odczytywać informacje do kilku różnych zmiennych:

cin >> a >> b >> c; // Odczyt kolejno do zmiennej a, b i c

// Przykładowy program w C++
// (C)2017 mgr Jerzy Wałaszek
// I LO w Tarnowie
//---------------------------

#include <iostream>

using namespace std;

int main()
{
    unsigned int wiek;

    cout << "Witaj. Ile masz lat? : ";
    cin  >> wiek;
    cout << "Teraz masz lat " << wiek
         << ". Ale za 15 lat bedziesz mial juz lat " << wiek + 15
         << ".\n\n";

    return 0;
}

W programie nie ma polskich znaków. Spowodowane jest to ty, iż firma Microsoft przyjęła inny sposób kodowania polskich literek w graficznym systemie Windows i inny w znakowym systemie konsoli. Rozwiązanie tego problemu pokażę później, na lekcji o tekstach w C++.

Przykładowe uruchomienie

zmienna = wyrażenie;

Komputer oblicza wartość wyrażenia i wynik umieszcza w podanej zmiennej. Znaku = nie traktuj jako równość matematyczną, jest to symbol operacji przypisania.

// Program  przeliczający stopnie
// Celsjusza na stopnie Fahrenheita.
// (C)2017 I LO w Tarnowie
//----------------------------------

#include <iostream>

using namespace std;

int main()
{
    int tc,tf;

    cout << "Przeliczanie stopni Celsjusza na stopnie Fahrenheita\n"
            "----------------------------------------------------\n\n"
            "Temperatura w stopniach Celsjusza?  : ";
    cin  >> tc;

    tf = (9 * tc) / 5 + 32;

    cout << "Temperatura w stopniach Fahrenheita : " << tf << endl << endl;

    return 0;
}

// Program  obliczający drogę w ruchu jednostajnie
// przyspieszonym.
// (C)2017 I LO w Tarnowie
//----------------------------------

#include <iostream>

using namespace std;

int main()
{
    int s,V0,t,a;

    cout << "Droga w ruchu jednostajnie przyspieszonym\n"
            "-----------------------------------------\n\n"
            "Vo = "; cin >> V0;
    cout << "t  = "; cin >> t;
    cout << "a  = "; cin >> a;

    s = t * (V0 + a * t / 2);

    cout << "\n----------\n"
            "s  = " << s << endl;;

    return 0;
}

Wyrażenie z operatorem przypisania posiada wartość równą wartości wyrażenia po prawej stronie operatora. Przykład:

cout << (a = 5) << endl;
 

Wynikiem wykonania tej instrukcji jest liczba 5, ponieważ to stoi po prawej stronie operatora =. Dzięki tej własności możemy w języku C++ przypisać tę samą wartość do kilku zmiennych.

Zamiast pisać:

a = 5;
b = 5;
c = 5;

możemy zapisać prościej:

a = b = c = 5;

Operatory te można stosować na dwa sposoby:

Jeśli operacja zwiększania zmiennej jest samodzielną instrukcją, to nie ma znaczenia, który z tych sposobów użyjemy. Poniższe dwa programy dają identyczne wyniki:

// Modyfikacja zmiennej
// (C)2017 I LO w Tarnowie
//----------------------------------

#include <iostream>

using namespace std;

int main()
{
    int a = 125, b = 30;

    ++a;  --b;
    cout << a << " " << b << endl;

    return 0;
}

// Modyfikacja zmiennej
// (C)2017 I LO w Tarnowie
//----------------------------------

#include <iostream>

using namespace std;

int main()
{
  int a = 125, b = 30;

  a++;  b--;
  cout << a << " " << b << endl;

  return 0;
}

W obu programach tworzone są dwie zmienne a  i b. Zmiennej a  nadajemy wartość 125, a zmiennej b  30. Następnie program zwiększa zawartość zmiennej a  o 1 do 126, a zawartość zmiennej b  zmniejsza o 1 do 29. Na koniec zawartości zmiennych są kolejno wyświetlane i otrzymujemy liczby 126 i 29. W pierwszym programie operatory ++ i -- stosujemy przed zmiennymi, a w drugim po zmiennych.

Jeśli operator zwiększania ++ lub zmniejszania -- zastosujemy do zmiennej użytej w wyrażeniu, to bardzo istotne jest, którą z form wybierzemy:

Przykład:

// Modyfikacja zmiennej
// (C)2017 I LO w Tarnowie
//----------------------------------

#include <iostream>

using namespace std;

int main()
{
  int a = 125, b = 30,c,d;

  c = ++a;  d = --b;

  cout << a << " " << b << " "
       << c << " " << d << endl;

  return 0;
}

// Modyfikacja zmiennej
// (C)2017 I LO w Tarnowie
//----------------------------------

#include <iostream>

using namespace std;

int main()
{
  int a = 125, b = 30,c,d;

  c = a++;  d = b--;

  cout << a << " " << b << " "
       << c << " " << d << endl;

  return 0;
}

Programy różnią się jedynie sposobem umieszczenia operatorów ++ oraz -- w stosunku do modyfikowanej zmiennej. W obu przypadkach zmienna a  przyjmuje na końcu wartość 126, a zmienna b  29. Jednakże w pierwszym programie do zmiennej c  trafi 126 i do d  29, a w drugim do c  trafi 125, a do d  30. W pierwszym programie zmienna a  w wyrażeniu c = ++a; jest najpierw zwiększana z 125 na 126 i ten wynik trafia do zmiennej c. podobnie zmienna b  w wyrażeniu d = --b; zostanie najpierw zmniejszona do 29 i wynik ten trafi do zmiennej d. W drugim programie operatory ++ i -- umieszczone są za zmienną. Zatem w wyrażeniu c = a++; do zmiennej c  trafi najpierw zawartość zmiennej a, czyli 125, a następnie zmienna a  zostanie zwiększona do 126. Podobnie w wyrażeniu d = b--; do zmiennej d  trafi zawartość b, czyli 30, a następnie zmienna b  zostanie zmniejszona do 29.

Na opisane wyżej zjawisko należy bardzo uważać w programach C++, gdyż często prowadzi ono do trudno wykrywalnych błędów. Najbezpieczniej jest modyfikować zmienną poza wyrażeniami, lecz często robi się to wewnątrz wyrażeń w celu optymalizacji kodu. Wybór jest twój - zostałeś ostrzeżony.

Poza prostymi operatorami zwiększania lub zmniejszania o 1 zawartości zmiennej, język C++ posiada bogatą gamę operatorów modyfikacji:

    a += 2;     // zmienne a zostaje zwiększona o 2
    c += a + b; // zmienna c zostaje zwiększona o sumę zmiennych a i b

    a -= 3;     // zmienna a zostaje pomniejszona o 3
    b -= 2 * c; // zmienna b zostaje pomniejszona o 2 * c

    a *= 3;     // zmienna a zostaje pomnożona przez 3
    b *= c - d; // zmienna b zostaje pomnożona przez różnicę zmiennych c i d

    a /= 4;     // zawartość zmiennej a zostaje podzielona przez 4
    b /= c--;   // zawartość zmiennej b zostaje podzielona przez c, po czym c zostaje zmniejszone o 1

    a %= 10;    // w zmiennej a znajdzie się reszta z dzielenia a przez 10, czyli ostatnia cyfra dziesiętna
    a %= 2;     // w zmiennej a będzie 0, jeśli a było parzyste, lub 1, jeśli a było nieparzyste

Podane powyżej operatory modyfikacji (jak również instrukcje przypisania) mogą wystąpić w wyrażeniach, lecz odradzamy takie rozwiązania poza szczególnymi wyjątkami - prowadzą one do bardzo zawiłych kodów, które trudno później analizować:

a = 1; b = 2; c = 3; 
a = c + (b += 5 * (c *= 3 + b));  // odpowiedz bez uruchamiania, jaki będzie wynik w a?