Informatyka dla klasy IIK

Język C++

Języki programowania

Język programowania (ang. programming language) umożliwia wydawanie poleceń komputerowi. W pierwszych komputerach stosowano binarne kody instrukcji, które bezpośrednio rozumie komputer . Procesor najpierw pobiera kod instrukcji, a następnie analizuje go i na podstawie odpowiednich pól wykonuje określone operacje. Na przykład, w jednym z pierwszych komputerów Konrada Zuse program był tworzony na taśmie filmowej w postaci dziurek, które odzwierciedlały binarną postać instrukcji.

 

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.

 

 Asembler           Kod binarny
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:

 

 Asembler
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):

Język programowania C++

Grafika:BjarneStroustrup.jpg

Bjarne Stroustrup – twórca C++

 

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.

tworzenie
tekstu
programu
kompilacja
tekstu na
język
maszynowy
uruchomienie
programu
wynikowego

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.

Instalacja Code::Blocks w systemie Windows

Code::Blocks jest bardzo wygodną, darmową i legalną aplikacją, która służy do tworzenia programów w języku C i C++. Jest to tzw. zintegrowane środowisko programowania IDE (ang. Integrated Developement Environment), które zawiera edytor kodu z kolorowaniem składni, kompilator oraz program uruchomieniowy. Praca w środowisku zintegrowanym jest bardzo wygodna i szybka, ponieważ bierze ono na siebie wiele operacji, które programista musiałby wykonywać ręcznie, pracując bez takiego środowiska.

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ę:

Download the binary release

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.

 

Projekt w Code::Blocks

Utwórz na dysku katalog na projekty programów w języku C++. Uruchom Code::Blocks.

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:

 

-------------- Build: Debug in p01 (compiler: GNU GCC Compiler)---------------

mingw32-g++.exe -Wall -fexceptions -g -c D:\cprj\p01\main.cpp -o obj\Debug\main.o

mingw32-g++.exe -o bin\Debug\p01.exe obj\Debug\main.o

Output file is bin\Debug\p01.exe with size 27.77 KB

Process terminated with status 0 (0 minute(s), 1 second(s))

0 error(s), 0 warning(s) (0 minute(s), 1 second(s))

 

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:

 

Process returned 0 (0x0) execution time : 0.047 s
Press any key to continue.

 

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:

 

Process returned 155 (0x9B) execution time : 0.019 s
Press any key to continue.

 

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:

 

Witaj. Jestem twoim programem w C++

Process returned 0 (0x0) execution time : 0.031 s
Press any key to continue.

 

<< 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
//---------------------------------
  Komentarz
#include <iostream>
  Pliki nagłówkowe zawierające definicje używanych w programie struktur danych oraz funkcji bibliotecznych.
using namespace std;
  Jeśli wykorzystujemy elementy biblioteki STL, to wstawiamy do programu dyrektywę informującą kompilator o używanej przestrzeni nazw.
int main()
{
    cout << "Cześć. Jestem twoim programem w języku C++" << endl
         << "------------------------------------------" << endl << endl;
    return 0;
}
  Każdy program w języku C++ musi posiadać funkcję main(), od której rozpoczyna się wykonywanie programu. Zawartość tej funkcji określa to, co program robi.

 

Zmienne

Zwykle chcemy przetwarzać w programie pewne dane. Do ich przechowywania służą zmienne (ang. variables). Zmienna jest fragmentem pamięci komputera, w którym program przechowuje określoną informację. Przed pierwszym użyciem zmiennej musimy ją zadeklarować, czyli określić rodzaj przechowywanej w niej informacji oraz nazwę, poprzez którą będziemy się odwoływali w programie do tej informacji. Deklaracja zmiennej w języku C++ jest następująca:

 

typ_danych nazwa_zmiennej;

 

typ_danych    określa rodzaj przechowywanej w zmiennej informacji. Na poprzednich zajęciach poznaliśmy kod U2, który jest powszechnie używany do reprezentacji liczb całkowitych w systemach komputerowych. Typ int oznacza 32 bitową liczbę U2 o zakresie od -231 do 231 - 1, czyli około ± 2 mld. Będziemy również używali 32 bitowych liczb w naturalnym kodzie binarnym, który w języku C++ reprezentowany jest przez typ unsigned int, który oznacza 32 bitową liczbę NBC o zakresie od 0 do 232 - 1, czyli od 0 do około 4 mld.
nazwa_zmiennej    jest napisem, poprzez który uzyskujemy dostęp do informacji przechowywanej w zmiennej. Nazwy zmiennych zbudowane są z liter małych i dużych, cyfr oraz znaku podkreślenia. Pierwszym znakiem nazwy zmiennej powinna być litera (nie może być nim cyfra!). Zmienna nie powinna posiadać nazwy dłuższej od 31 znaków (tyle zwykle zapamiętują kompilatory C++). Nie wolno również zmiennym nadawać nazw identycznych ze słowami kluczowymi języka C++ (np. return, int, unsigned, itp.). Nazwa zmiennej powinna kojarzyć się ze spełnianą funkcją w programie: lepiej użyć nazw Wynik, nazwisko, konto od Q12XC5, r74SY8 czy a_7dnm99VCD.

 

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

Witaj. Ile masz lat? : 18
Teraz masz lat 18. Ale za 15 lat bedziesz mial juz lat 33.


Process returned 0 (0x0) execution time : 3.037 s
Press any key to continue.
 

Operator przypisania

Do przetwarzania danych w programie C++ używany jest operator przypisania (ang. assignement operator). Posiada ona następującą postać:

 

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;
 

Instrukcje modyfikacji zmiennej

Język C++ posiada dwa użyteczne operatory do zwiększania i zmniejszania zawartości zmiennej:

 

++  - zwiększa zawartość zmiennej o 1
--  - zmniejsza zawartość zmiennej o 1

 

Operatory te można stosować na dwa sposoby:

 

++ zmienna    lub    zmienna ++
-- zmienna
    lub    zmienna --

 

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:

 

++ zmienna, -- zmienna : najpierw modyfikuje zawartość zmiennej, a następnie wynik jest używany do obliczeń w wyrażeniu
zmienna ++, zmienna -- : w wyrażeniu stosowana jest bieżąca zawartość zmiennej, a następnie po wyliczeniu wyrażenia zmienna jest modyfikowana.

 

Przykład:

Poniższe dwa programy dają różne wyniki:

 

// 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:

 

zmienna += wyrażenie; - zwiększa zawartość zmiennej o wartość wyrażenia:
    a += 2;     // zmienne a zostaje zwiększona o 2
    c += a + b; // zmienna c zostaje zwiększona o sumę zmiennych a i b

zmienna -= wyrażenie; - zmniejsza zawartość zmiennej o wartość wyrażenia:

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

zmienna *= wyrażenie; - mnoży zawartość zmiennej przez wartość wyrażenia

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

zmienna /= wyrażenie; - dzieli zawartość zmiennej przez wartość wyrażenia

    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

zmienna %= wyrażenie; - w zmiennej zostanie umieszczona reszta z dzielenia tej zmiennej przez wartość wyrażenia:

    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?

 



List do administratora Serwisu Edukacyjnego Nauczycieli I LO

Twój email: (jeśli chcesz otrzymać odpowiedź)
Temat:
Uwaga: ← tutaj wpisz wyraz  ilo , inaczej list zostanie zignorowany

Poniżej wpisz swoje uwagi lub pytania dotyczące tego rozdziału (max. 2048 znaków).

Liczba znaków do wykorzystania: 2048

 

W związku z dużą liczbą listów do naszego serwisu edukacyjnego nie będziemy udzielać odpowiedzi na prośby rozwiązywania zadań, pisania programów zaliczeniowych, przesyłania materiałów czy też tłumaczenia zagadnień szeroko opisywanych w podręcznikach.



   I Liceum Ogólnokształcące   
im. Kazimierza Brodzińskiego
w Tarnowie

©2017 mgr Jerzy Wałaszek

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