Programmeerimine keeles C++ 2022/23 kevad

Sissejuhatus kursusesse

Eessõna

Selles kursuses eeldame, et üliõpilane on läbinud programmeerimise algkursuse (nt keele Python baasil). Seetõttu käsitletakse keelekonstruktsioonidest vaid olulisemaid aspekte. Antud kursus ei eelda programmeerimiskeele Java tundmist.

NB! Palun kõigist vigadest ja ebatäpsustest, samuti ettepanekutest materjalide parandamiseks kirjutada helle.hein@ut.ee.

Õpiväljundid

Pärast selle praktikumi läbimist üliõpilane

• oskab koostada, kompileerida ja käivitada väga elementaarseid C++ programme;
• oskab nimetada mõned olulised erinevused C++ ja Pythoni vahel, eriti need, mis teda võivad edaspidi häirida;
• teab keeles C++ kasutatavaid põhilisi andmetüüpe;
• teab, kuidas kompileerida käsuga make ja mis on Makefile;
• lahendab oma kodused ülesanded iseseisvalt ja on nõus selle nimel ka vaeva nägema;
• ei karda kaaslastelt ja õppejõult nõu küsida.

Muutujad ja andmetüübid

Esmatutvus C++-ga. Esimene programm. Kompileerimine. Sisend-väljund. Programmi struktuur. Muutujad ja andmetüübid. C++ vs Python (põhikonstruktsioonid).

Keskkonna seadistamine

C++ programmide loomiseks võib kasutada erinevaid keskkondi. Käesolevas kursuses kasutame koodi loomiseks Visual Studio Code (https://code.visualstudio.com/, vt installeerimisjuhendit) ja kompileerimiseks kompilaatorit gcc (vt installeerimisjuhendit). Samuti on võimalik kasutada keskkonda Clion (https://www.jetbrains.com/clion/), mille installeerimisel ei pea eraldi kompilaatori gcc pärast muretsema.

Käesoleva materjali koostamisel on kasutatud graafilist keskkonda Clion ja kompileerimiseks käsku g++.

Standard ISO/IEC 14882 (2020) määrab nõuded programmeerimiskeele C++ implementeerimiseks.

Kuidas erinevad kompilaatorid toetavad keele võimalusi, seda saab vaadata siit:

https://en.cppreference.com/w/cpp/compiler_support

Juhendite lingid

Windows arvuti VSCode ja MSYS2 ülesseadmine (inglise keeles) https://code.visualstudio.com/docs/cpp/config-mingw

Windows arvuti juhend (vanast kursusest) https://courses.cs.ut.ee/2023/cpp/spring/Main/WorkingWithWindows

Linux arvuti juhend (vanast kursusest) https://courses.cs.ut.ee/2023/cpp/spring/Main/WorkingWithLinux

C++ arendusvahendid Mac OS X jaoks (vanast kursusest) https://courses.cs.ut.ee/2023/cpp/spring/Main/WorkingWithOSX

Programmi kirjutamine

Loome tekstifaili, paneme nimeks esimene.cpp ja kopeerime sinna alljärgneva teksti

// Minu esimene C++ programm 
#include <iostream>
using namespace std;

int main(){
  cout << "Tere, maailm!";
  return 0;
}

Kompileerimine ja käivitamine

Enne täitmist tuleb C++ programm teisendada täidetavaks programmifailiks (nt Windows korral .exe fail). See protsess koosneb üldjuhul kolmest osast: eelprotsessori (preprocessor) töö, kompileerimine (compiling) ja linkimine (linking). Kõiki tööetappe juhitakse kompilaatori parameetritega (sellest edaspidi). Graafilises töökeskkonnas (nt Clion) püütakse neid etappe kasutaja eest varjata. Meie esimese programmi korral eraldi linkimiskäsku ei ole vaja ja kompileerimiseks sisestame käsurealt (nt Windowsi käsuviip)

>g++ -std=c++20 esimene.cpp

Selle tulemusena tekib käivitatav programm a.exe. Programmi käivitamiseks sisestame käsurealt

>a.exe

Tulemuseks on ekraanil

Tere, Maailm!

Kui soovime käivitatavale failile nime panna (nt esimene.exe), siis lisame kompilaatorile -o ja faili nime:

>g++ -std=c++20 esimene.cpp -o esimene

Vaatame nüüd programmi lähemalt ühe rea kaupa

// Minu esimene C++ programm 
#include <iostream>
using namespace std;

int main(){
    cout << "Tere, maailm!";
    return 0;
}

Rida 1

// C++ kommentaarid rea lõpuni. Mitmerealine kommentaar tuleb paigutada /* ja */ vahele.

Rida 2

#include <iostream> 

Käsk #include <iostream> annab kompilaatorile teada, et on vaja enne kompileerimist võtta kogu kood iostream päisefailist ja paigutada programmi. Päisefail iostream võimaldab kasutada sisend/väljund voogu (nt lugeda klaviatuurilt cin ja väljastada ekraanile cout). Päisefailide kaasamine programmis annab võimaluse kasutada juba varem valmiskirjutatud koodi.

Rida 3

using namespace std;

annab kompilaatorile teada, et kasutatakse "standard nimeruumi". Nimeruumid aitavad vältida konflikte suuremates programmides. Selle rea puudumisel tuleb rea 6 asemel kirjutada std::cout << "Tere, maailm!";.

Rida 4 on tühi, seda C++ kompilaator ignoreerib.

Read 5-8

int main(){
...
return 0;
}

Defineeritakse funktsioon nimega main, mis tagastab täisarvu. Antud juhul tagastatakse arv 0 (return 0;), mis tähistab programmi töö edukat lõppu. Funktsiooni sisu on loogeliste sulgude sees ({}) ja iga käsk lõpeb semikooloniga (;). Igas C++ programmis peab olema main funktsioon, kust programmi töö algab.

NB! C++ keel on tõstutundlik, st main ja Main on erinevad funktsioonid.

Rida 6

cout << "Tere, maailm!";

Ekraanile kuvamiseks saab kasutada standardväljundit cout, kuhu suunatakse info märkide << abil. Kui jätame ära rea 3 (standardnimeruumi kasutamise), siis tuleb näidata nimeruum ilmutatult

std::cout << "Tere, maailm!";

Väljundisse saab saata ka mitu infoühikut, nt

cout << "Tere, maailm! " << "See on minu esimene C++ programm." << endl;

Peale kompileerimist ja käivitamist on ekraanil

Tere, maailm! See on minu esimene C++ programm. 

Käsu lõpus olev endl lõpetab rea ja järgmine väljund läheb uuele reale.

NB! Dokumendis Bjarne Stroustrup, Herb Sutter "C++ Core Guidelines", September 23, 2022

https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#c-core-guidelines

soovitatakse käsku endl mitte kasutada, kuna see aeglustab programmi tööd. Selle asemel hakkame kasutama juba varem tuntud uuele reale mineku käsku '\n'.

cout << "Tere, maailm! " << "See on minu esimene C++ programm.\n";

Kui Pythonis on funktsiooni sisu taandega eraldatud, siis C++ taanet ja reavahetusi ei nõua, küll on seda programmi loetavuse huvides väga soovitav ikkagi teha. Põhimõtteliselt on töötav ka järgmine main funktsioon:

int main(){cout << "Tere, maailm!";return 0;}

Selline programm on aga väga halvasti loetav.

Kompileerimisest

Programmide kompileerimise ja käivitamise mõistmiseks on oluline teada, kuidas C++ kompileerimine töötab. C++ lähtekoodi kompileerimine masinloetavaks koodiks koosneb järgmisest neljast protsessist:

1. Lähtekoodi eeltöötlus preprotsessori (preprotsessor) poolt.

Preprotsessori direktiivid on programmi koodis sisalduvad read, mille alguses on märk #. Preprotsessor töötleb direktiive enne kompileerimise algust. Näiteks, kui koodis on preprotsessori direktiiv #include, siis asendab ta selle faili sisuga, luues laiendatud lähtekoodifaili.

2. Lähtekoodi kompileerimine.

Peale preprotsessori tööd kompileeritakse kood laiendatud lähtekoodifailideks platvormile sobivas keeles.

3. Objektkoodifailide (.o) kokkupanek.

Laiendatud lähtekoodifailid teisendatakse objektikoodifailideks.

4. Objektikoodifailide linkimine käivitatava faili loomiseks.

Objektikoodifailid lingitakse koos standardteegi ja muude teekide objektikoodifailidega kokku, et luua käivitatav fail, nt laiendiga .exe.

Makefile

Kuidas kompileerida makefile-ga ja milliseid käske saab kasutada, saab uurida siit:

https://sander-saarpere.gitlab.io/makefile-tutorial/

https://makefiletutorial.com/#getting-started

https://makefiletutorial.com/

Kiire kokkuvõte alustamiseks:

Makefile ja make tööriist on mõeldud lihtsustama programmide kompileerimist ja haldamist. C ja C++ programmid kasvavad tihti suureks ja paremaks haldamiseks eraldatakse kood mitmesse faili. Vältimaks olukorda, kus käsureal peab need failid ükshaaval kompileerima, saab need make abil taandada üheks käsuks. make ise jälgib failide ajatempleid ja kompileerib ainult need failid, milles on uuendusi tehtud, kiirendades sellega kompileerimisaega. Samuti saab make abil automatiseerida muud käsurea funktsionaalsust, nagu näiteks kaustade loomine ja failide kustutamine.

make kasutamiseks peab olema projekti juurkaustas fail nimega Makefile ilma ühegi faililaiendita ja avatud terminaliaken, mis on samuti projekti juurkaustas. Vaatleme Makefile’i, mis prindib käsureale „Hello world!“:

# Käsk prindib välja helloWorld
hello:
	echo "Hello World!"

Käsurealt „make hello“ jooksutamine annab järgmise väljundi:

PS C:\RandomComputer> make hello
echo "Hello World!"
Hello World!
PS C:\RandomComputer>

Vaatame täpsemalt Makefile'i süntaksit. Makefile erineb tavalisest programmist, mida täidetakse rida-rea haaval ülevalt alla. Makefile koosneb peamiselt reeglitest, mille järjekorra make paneb ise paika, et saada soovitud tulemus. Reeglite süntaks on järgnev:

Sihid (Targets) : Eeltingimused (prerequisites)
	Käsk (Command)
	Käsk (Command)
	...

Sihiks on failinimi, mida tahetakse saada selle reegli täitmisel, või isetehtud käsunimi, mis paneb tööle reeglis kirjeldatud käskude ahela. Tavaliselt on neid üks reegli kohta.
Eeltingimusteks on nimekiri tühikuga eraldatud failidest, mis peavad olemas olema juurkaustas või konkreetses alamkataloogis, või reeglitega loodud käskudest, mis peab eelnevalt ära täitma.
Käsud on sammud, mis käivitatakse üksteise järel käsureal, et tavaliselt saada sihiks olev fail. Tähtis on, et kõik käsud algavad tabulaatoriga.
Kommentaar on sarnaselt Pythonile #-sümboliga, kuid peab tähelepanu pöörama, et see oleks esimene sümbol real, vastasel juhul see liidetakse ülejäänud käsule juurde ning võib põhjustada vigu.
Vaatame järgmise näitena C++ "Hello World!" programmi:

// Minu esimene C++ programm
#include <iostream>
using namespace std;

int main(){
  cout << "Tere, maailm!";
  return 0;
}

Selle kompileerimiseks oleks Makefile järgn ev:

a.exe: esimene.cpp
	g++ esimene.cpp
run: a.exe
	./a.exe

Failis on kirjeldatud reegel esimene.cpp kompileerimiseks ja ka eraldi käsk, mis nõuab a.exe2 reegli eelnevat täitmist. Kirjutades käsureal make a.exe, kontrollib make, kas esimene.cpp eksisteerib (vastasel juhul annab veateate), ja kompileerib C++ faili a.exe failiks. Kirjutades make run tehakse kaks sammu korraga, alguses kompileeritakse ja siis kohe ka käivitatakse saadud programm.

Sarnaselt teistele programmeerimiskeeltele, saab Makefile sees defineerida muutujaid korduvate tekstilõikude jaoks. Näiteks levinud muutujad:

CXX := g++
CXXFLAGS := -g 

Failis defineeritakse kaks muutujat, CXX määrab, mis kompilaatorit kasutatakse ja CXXFLAGS määrab kompileerimiseks kasutatavad lipud, praegusel juhul -g ütleb kompilaatorile, et lisataks silumiseks vajalik informatsioon. Kasutamaks neid ülejäänud failis, peab kasutama $ sümbolit. Näiteks Hello World programmi Makefile:

a.exe: esimene.cpp
	$(CXX) $(CXXFLAGS) esimene.cpp
run: a.exe
	./a.exe

Kasulikud lipud:
-Wall – Kompileerija näitab suuremal hulgal hoiatusi koodi kohta.
-Werror – Muudab kõik hoiatused vigadeks, nii et kompileerija katkestab töö.
-o – Saab nimetada väljundfaili, milleks on sellele kohe järgnev failinimi.
-c – Kompileeritakse fail, aga ei lingita. Kasutada mitme lähtekoodifaili puhul.
-I – Ütleb kompilaatorile, kust kaustast otsida eelprotsessori #include käsu jaoks .h faile. Kausta nimi järgneb tühikuta lipule, tavaliselt -Iinc.

Muutujad ja andmetüübid

Programmeerimiskeeles C++ (erinevalt Pythonist) peab nii muutuja tüüp kui ka funktsiooni tagastustüüp olema ilmutatult määratud. Näiteks täisarvu tüüpi muutuja deklareerimiseks saame kasutada tüüpi int

int arv;

Kui tahame näiteks kasutada täisarvutüüpi muutujaid arv1 ja arv2 ning ujukomaarvu ujuarv, saame kasutada tüüpe int ja float.

int arv1, arv2;
float ujuarv;

Muutuja kirjeldamise hetkel on muutuja väärtus määramata, seda saab teha hiljem

arv1 = 1;
arv2 = arv1 + 1;
ujuarv = 5.2;

Muutuja kirjeldamist ja talle väärtuse määramist saab ühendada ja seda nimetatakse muutuja initsialiseerimiseks.

Muutujate initsialiseerimine

Programmeerimiskeeles C++ on võimalik muutujat initsialiseerida kolmel viisil

• C-tüüpi initsialiseerimine (päritud keelest C)

int arv = 10;

Avaldist int arv = 10; nimetatakse omistamislauseks (assignment statement) ja = omistamisoperaatoriks (assignment operator). C++ keeles kasutatakse ka teistes keeltes tuntud liitomistamisoperaatoreid (compound assignment operators): +=, -=, *=, /=, %=.

• konstruktor-tüüpi initsialiseerimine (C++ originaalkonstruktsioon)

int arv(10);

• ühtne (uniform) initsialiseerimine (alates C++ standardist 2011). Arvulise muutuja initsialiseerimise korral tühjade loogeliste sulgudega on muutuja vaikeväärtuseks 0. Järgmises näites muutuja arv1 väärtuseks on 0.

int arv{10};
long arv1{};

Soovituslik on kasutada seda initsialiseerimisviisi nii palju kui võimalik. Edaspidi püüame sellest kinni pidada.

Muutuja nimeks kasutame tähega algavat tähtedest ja numbritest koosnevat sõnet, mis võib sisaldada ka alakriipsu _. Täpsem definitsioon on aadressil https://en.cppreference.com/w/cpp/language/identifiers

NB! C++ on tõstutundlik, nt muutujad arv ja Arv on erinevad muutujad.

Andmetüübid

Andmetüübid jagunevad

• fundamentaalsed (fundamental)
• liittüübid (compound)

Selles peatükis vaatleme ainult fundamentaal- ehk lihttüüpe, liittüüpe ja tüüpi nullptr käsitleme hiljem. Tüübi suurus baitides ja esituse täpsus varieerub sõltuvalt riistvarast ja operatsioonisüsteemist. Lihttüüpidest annab ülevaate järgmine tabel (kaldkirjas võtmesõnad on lubatud ära jätta).

Täisarvud on vaikimisi märgiga (näiteks tüübi char väärtusvahemik on -128 kuni 127). Kui on vaja ainult mittenegatiivseid arve, tuleb lisada tüübitäpsustus unsigned. Näiteks märgita kahebaidise täisarvu väärtusvahemik on 0 kuni 65535. Funktsioon sizeof annab tüübi või muutuja suuruse baitides:

short sh{-345};
unsigned long long ull{345};
cout << "Tüübi 'short' suurus on " << sizeof(short) << " baiti.\n";
cout << "Muutuja  'ull' suurus on " << sizeof(ull) << " baiti.\n";

Tüübi 'short' suurus on 2 baiti.
Muutuja  'ull' suurus on 8 baiti.

NB! Näiteks järgmine rida

unsigned int ui{-5}; //kompileerimisviga

annab kompileerimisvea, sest märgita täisarvutüüpi muutujale püütakse omistada negatiivset arvu.

Tõeväärtustüübil bool on kaks väärtust: true ja false. Tegelikult esitatakse tõeväärtust täisarvuna; täisarv 0 (null) esitab tõeväärtust false ja kõik ülejäänud täisarvud esitavad tõeväärtust true (vaikimisi 1).

bool ilus_ilm{true};
cout << "Täna on ilus ilm: " << ilus_ilm << "\n";
cout << boolalpha << "Täna on ilus ilm: " << ilus_ilm << "\n";

Täna on ilus ilm: 1
Täna on ilus ilm: true

Käsuga boolalpha antakse väljundisse korraldus väljastada tõeväärtused võtmesõnadega true ja false.

Tüüp void tähistab tüübi puudumist, kasutatakse näiteks funktsiooni nime ees. Selle kasutamist vaatame järgmises peatükis.

Märkus: char tüübi puhul tasub arvestada, et väljastusel kirjutatakse ekraanile vastav tähemärk, mitte arv. Näiteks

 char x{65}; cout << x; 

char märk{65} ; // ASCII kood 'A' jaoks
cout << "Tähemärk : " << märk << "\n";
cout << "Tähemärgi kood (int) : " << static_cast<int>(märk) << "\n";

Tähemärk : A
Tähemärgi kood (int) : 65

Märgime siin, et keeles C++ ümbritsetakse char tüüpi literaal ülakomadega (''), seevastu sõneliteraal ümbritsetakse jutumärkidega ("").

Avaldised

Aritmeetiliste operaatoritega (tehetega) keeles C++ saab tutvuda aadressil https://en.cppreference.com/w/cpp/language/expressions Peatume siin vaid täisarvude jagamisel ja jagamise jäägil

int arv1{2};
int arv2{7};
int tulemus;
tulemus = arv2 / arv1;
cout << "7/2 =  " << tulemus << "\n";
tulemus = arv2 % arv1;
cout << "7%2 =  " << tulemus << "\n";

7/2 =  3
7%2 =  1

Kui soovime teostada täpset jagamist, st saada tulemuseks ujukomaarvu, siis peab vähemalt üks operandidest olema ujukomaarvu tüüpi:

int arv1{2};
float arv2{7};
cout << "7/2 =  " << arv2 / arv1 << "\n";

7/2 =  3.5

Keeles C++ on defineeritud ka operaatorid ++ (increment) ja -- (decrement). Need operaatorid kas suurendavad (++) või vähendavad -- muutujat ühe võrra. Kui operaator on muutuja ees (pre-increment või pre-decrement), siis avaldise arvutamisel kasutatakse muutuja uut väärtust. Kui operaator on muutuja järel (post-increment või post-decrement), siis avaldise arvutamisel kasutatakse muutuja vana väärtust ja muutuja saab uue väärtuse peale käsu täitmist. Vaatame näidet:

int value{5};
cout << "Väärtust suurendatakse (post-increment) : " << value++ << "\n";
cout << "Uus väärtus : " << value << "\n";
value = 5;
cout << "Väärtust suurendatakse (pre-increment): "  << ++value << "\n";
cout << "Uus väärtus : " << value << "\n";

Väärtust suurendatakse (post-increment) : 5
Uus väärtus : 6
Väärtust suurendatakse (pre-increment): 6
Uus väärtus : 6

Tüübiteisendused

Aritmeetilistes avaldistes on soovitatav kasutada sama tüüpi muutujaid. Kui siiski kasutatakse eri tüüpi muutujaid (või literaale, neist hiljem), siis kompilaator leiab avaldise tüübi avaldises esineva kõige 'suurema' tüübi järgi, kasutades selleks kindlaid reegleid. Reeglitega saab tutvuda lehel https://en.cppreference.com/w/cpp/language/implicit_conversion.

Näiteks

• signed char või signed short saab teisendada tüübiks int
• unsigned char või unsigned short saab teisendada tüübiks int, kui int suudab mahutada kogu esitusvahemiku, vastasel juhul teisendatakse tüübiks unsigned int.

Toome siin tüüpide hierarhia alates tüübist int. Kompilaator püüab teisendada hierarhias alates 'väiksemast' esimeseks võimalikuks tüübiks.

Võtmesõna auto - kohatäide (placeholder)

Alates C++11 on keeles võimalus, et kompilaator ise tuvastab muutuja tüübi. Selleks võib muutuja defineerimisel tüübi asemel kirjutada võtmesõna auto. Järgmises näites funktsioon sizeof tagastab muutuja või literaali poolt hõivatava baitide arvu mälus.

auto b{true}; //b on boolean
auto ch{'a'}; //ch on char
auto y{1.23}; //y on double
int täisarv{3};
float ujukomaarv{5.2};
auto x{täisarv + ujukomaarv}; // x on float
cout << sizeof(x) << '\n'; // 4
cout << sizeof(5.2 + 3) << '\n'; // 8 

4
8

Arvulise tüübi asemel võib kasutada auto, kui ei ole vaja täpselt defineerida muutuja esitusvahemikku (nt täisarvutüüpide korral unsigned int vs int). Kohatäite auto kasutusvaldkond ei piirdu arvuliste tüüpidega, vt https://en.cppreference.com/w/cpp/language/auto.

Arvuliste väärtuste omistamisel saab väärtusele lisada sufiksi, mis määrab tüübi. Näiteks L lisamisel on arv long tüüpi. Sufiksitest annab ülevaate järgmine tabel:

Kaheksand- ja kuueteistkümnendsüsteemi arvude esitamisel kasutatakse prefikseid 0 ja 0x:

int oct{015}; 
int hex{0x3AF};   

Bitikaupa operaatorid

Bitikaupa operaatorid on lubatud int ja char (ja nende variatsioonid) tüüpi operandidega. C++ toetab järgmisi bitikaupa operaatoreid

Võtmesõna const

Muutujaid, mille nime ees const, ei saa programmi töö käigus muuta. Sellise muutuja defineerimisel tuleb see ka algväärtustada kas ilmutatult või riistvaraliste vahendite abil.

const int a{10};  

Kompilaator saab paigutada sellise muutuja paigutada ROM mälutsooni.

Standardsisend (cin)

Standardsisendit cin kasutatakse koos märkidega >>. Järgmise programmi käivitamisel kasutaja sisestab klaviatuurilt 23 ja vajutab ENTER):

#include <iostream>
using namespace std;
int main ()
{
  int arv;
  cout << "Palun sisesta täisarv:";
  cin >> arv;
  cout << "Sisestatud arv on " << arv;
  cout << " ja selle ruut on " << arv*arv << ".\n";
  return 0;
}

Palun sisesta täisarv:23
Sisestatud arv on 23 ja selle ruut on 529.

Sisestada saab ka mitu andmeühikut, eraldades neid tühikuga:

int pikkus, laius, kõrgus;
cout << "Palun sisesta risttahuka pikkus, laius ja kõrgus:";
cin >> pikkus >> laius >> kõrgus;
cout << "Risttahuka ruumala on " << pikkus*laius*kõrgus << ".\n";

Palun sisesta risttahuka pikkus, laius ja kõrgus:2.1 3.2 4.3
Risttahuka ruumala on 28.896.

NB! Enesetestides eeldame, et on kasutatud standardnimeruumi (using namespace std;)