A C++ programozsi nyelv

kzpiskolsoknak

Szerkesztette:
Pnczl Istvn

2015. jnius

1
Tartalom
Elsz .........................................................................................................................................................4
1. Trtneti ttekints ....................................................................................................................................5
2. Bevezets ...................................................................................................................................................5
3. A C++ nyelv alapelemei ............................................................................................................................7
a) A C++ nyelv jelkszlete .......................................................................................................................7
b) A C++ nyelv azonosti .......................................................................................................................7
c) Konstansok ...........................................................................................................................................8
d) Megjegyzsek .......................................................................................................................................9
e) Opertorok s rsjelek .......................................................................................................................9
4. C++ program szerkezete ..........................................................................................................................10
a) Egyetlen modulbl felpl C++ program ......................................................................................10
b) Tbb modulbl ll C++ program ...................................................................................................10
5. A C++ alaptpusai, vltozk, konstansok ................................................................................................10
a) A C++ nyelv tpusai ...........................................................................................................................11
b) Egyszer vltozk definilsa ..........................................................................................................11
c) Konstansok a C++ nyelvben .............................................................................................................11
d) rtkek ...............................................................................................................................................12
6. Opertorok s kifejezsek ........................................................................................................................12
7. A C++ nyelv utastsai ............................................................................................................................14
a) Szabvnyos be- s kimenet utastsok .............................................................................................15
b) Az if utasts.......................................................................................................................................18
c) Az if-else szerkezet .............................................................................................................................19
d) Egymsba gyazott if utastsok ......................................................................................................20
e) Az else-if szerkezet .............................................................................................................................20
f) A switch utasts .................................................................................................................................21
g) A ciklus utastsok .............................................................................................................................23
h) A break, continue s a return utastsok ........................................................................................25
i) Defincik bevitele az utastsokba ...................................................................................................26
8. Szrmaztatott adattpusok ........................................................................................................................27
a) Egydimenzis tmbk .......................................................................................................................27
b) Vektor .................................................................................................................................................31
c) Tbbdimenzis tmb .........................................................................................................................38
d) Sztringek ............................................................................................................................................40
e) A String osztly ..................................................................................................................................41
f) A struktra tpus ................................................................................................................................48
9. Fggvnyek..............................................................................................................................................49
10. Fjlkezels .............................................................................................................................................54
Fggelk ..................................................................................................................................................57
2
Programozsi ttelek ....................................................................................................................................57
1) Az sszegzs ttele .............................................................................................................................57
2) Az eldnts ttele ...............................................................................................................................58
3) A kivlaszts ttele ............................................................................................................................59
4) A megszmlls ttele .......................................................................................................................60
5) A lineris keress ttele .....................................................................................................................61
6) A maximum s minimum rtk keress ttele ................................................................................62
7) A kivlogats ttele ............................................................................................................................63
8) A kzvetlen kivlasztsos rendezs ttele ........................................................................................64

3
 Elsz
Ez a dokumentum nem ms, mint a kzpiskols dikokat segt jegyzet. Az itt szerepl informci-
k klnbz forrsokbl szrmaznak, a forrslista lejjebb lthat. Megprbltam sszeszedni, kigyjteni
azokat az alapvet ismereteket, melyek szksgesek a programozs alapjainak megismershez, illetve az
emelt szint informatika rettsgi teljestshez.
gy gondoltam, hogy a C++ nyelv a legalkalmasabb erre a clra. Br nem az egyik legknnyebben
tanulhat programozsi nyelv, azonban kellen magas szint nyelv ahhoz, hogy nagy projektekben is
hasznlhat legyen, ugyanakkor kellen alacsony szint is, hogy lssuk egy kicsit az alapokat. A C++
nyelv tovbbra is ott van a vilgon legjobban hasznlt programozsi nyelvei kztt, ez vitathatatlan. Az
ebben a nyelvben szerzett tudssal, sokkal knnyebben tanulhat utna brmely ms magasabb szint
nyelv. Az elmlet mellett konkrt, gyakorlati pldkkal szemlltetem az aktulis ismeretanyagot.
A jegyzet vgn, a fggelk rszben mg tbb gyakorlati feladat lthat, melyet ajnlatos nllan
is vgigcsinlni. Az alapvet programozsi tteleken kvl az eddigi emelt szint informatika rettsgi
feladatainak megoldsa is megtallhat C++ nyelven. Termszetesen sajt feladatot is kitallhat brki
magnak, s azt megoldhatja. Ezen kvl vannak informatika feladatgyjtemnyek is, melyeket szintn
rdemes ttanulmnyozni s a bennk lv feladatokat megoldani.
Mg egyszer hangslyoznm, hogy ez a jegyzet nem az n nll munkm, a C++ nyelvet nem n
alkottam meg, s nem is fejlesztem. Egyszeren csak a dikoknak prblok segteni azzal, hogy a kln-
bz papr alap, illetve elektronikus forrsokbl sszeszedtem s rendszereztem azokat az alapvet
programozsi ismereteket, melyek az emelt szint informatika rettsgihez kellenek. Teht itt csak az
alapokat ismerhetjk meg, ha valaki programoz szeretne lenni, akkor bizony mlyen bele kell merlni az
ltalam is felhasznlt szakirodalmakba, s a matematikval is bartsgban kell lenni.
A programoz a 21. szzad kiemelt mestersge, a tuds elsajttsa nagy szorgalmat, kitartst
ignyel, de a legfontosabb a mindennapi gyakorls, programozi munka. Persze elszr el kell vgezni
megfelel iskolkat, attl fggen, hogy ki milyen szintre szeretne eljutni ezen a terleten (OKJ-s kpzs,
fiskola, egyetem, BSc kpzs, MSc kpzs). Ezzel persze mg kzel sem lett senki programoz, fleg j
programoz. Mi kell mg? Ht sokvi programozi gyakorlat (minimum 8 10 v), lland napraksz
tuds, fogkonysg az j dolgok irnt, folyamatos szakmai fejlds.
Sok sikert mindenkinek, aki ezt a jegyzetet elolvassa, s ezt az irnyt vlasztja.

A felhasznlt irodalom:
Bjarne Stroustrup A C++ programozsi nyelv
Benk Tiborn Poppe Andrs Egytt knnyebb a programozs Objektum-orientlt C++
Tth Bertalan ANSI C++ sszefoglal

4
1. Trtneti ttekints
A C++ nyelv kidolgozsa az AT&T Bell Laboratriumoknl dolgoz Bjarne Stroustrop nevhez fzdik.
Mint ahogy ismeretes a C nyelvet szintn itt fejlesztettk ki a 70-es vek elejn. gy nem kell csodlkozni
azon, hogy a tz vvel ksbbi C++ fejleszts a C nyelvre plt. A C nyelv ismerete ezrt teljesen term-
szetes kiindulpont a C++ nyelv megismershez. Bjarne Stroustrop kt f szempontot tartott szem eltt
a C++ kidolgozsnl:
A C++ nyelv legyen fellrl kompatibilis az eredeti C nyelvvel
A C++ nyelv bvtse ki a C nyelvet a Simula 67 nyelvben hasznlt osztlyszerkezettel (class)
Az osztlyszerkezet, amely a C nyelv struct adatszerkezetre plt, lehetv tette az objektum-orientlt
programozs (OOP) megvalstst.
A C++ nyelv tbb szakaszban nyerte el mai formjt. A C++ Version 1.2 vltozata terjedt el elszr a
vilgon (1985). A hasznlata sorn felvetdtt problmk s ignyek figyelembevtelvel Bjarne
Stroustrop kidolgozta a Version 2.0 nyelvdefincit (1988). A jelents vltoztatsok miatt a rgi C++
(1.2) nyelven rt programok ltalban csak kisebb-nagyobb javtsok utn fordthatk le a 2.0-s verzit
megvalst fordtprogrammal. Az vek folyamn a C++ nyelv jabb defincii (3.x) jelentek meg,
azonban a lnyeges jdonsgok kt nagy csoportba sorolhatk:
kivtelek (exception) kezelse
paramterezett tpusok, osztlyok s fggvnyek hasznlata (templates, sablonok)
A C nyelvet tbb lpsben szabvnyostottk. Az els (ANSI) szabvny 1983-ban jelent meg, gy alapul
szolglhatott a C++ nyelv megformlshoz. A C szabvnyt 1989-ben revzi al vettk (IOS/IEC), majd
1995-ben kibvtettk a szles karakterek (wchar_t) hasznlatnak lehetsgvel. A C++ szabvny kidol-
gozsban a ANSI X3J16 s az ISO WG21 bizottsgok vettek rszt a 90-es vek els felben. Munkjuk
eredmnyeknt 1997 novemberben megszletett az ANSI/ISO C++ szabvny, melyre a napjainkban
hasznlt legtbb C++ fordtprogram pl.
Mieltt elkezdennk a szabvnyos C++ nyelv elemeinek bemutatst, le kell szgeznnk, hogy a C++
nyelv a C nyelv szintakszisra pl nll programozsi nyelv. Alapvet eltrs a kt nyelv kztt, hogy
amg a C csak gyengn tpusos nyelv, addig a C++ ersen tpusos. Nem csak megengedi, de ersen tmo-
gatja is az objektum-orientlt programozst.
2. Bevezets
A C++ egy ltalnos cl programozsi nyelv, melynek f alkalmazsi terlete a rendszerprogramozs.
Tmogatja az elvont adatbrzolst, az objektumorientlt programozst valamint az ltalnostott progra-
mozst. Az eredeti programozsi alapelv kzppontjban az eljrs ll (a kvnt szmtshoz szksges
algoritmus). A nyelvek ezt az alapelvet fggvnyparamterek tadsval s a fggvnyek ltal visz-
szaadott rtkekkel tmogatjk. Az algoritmus nem ms, mint egy problma megoldsnak vges szm
rszlpsben trtn egyrtelm, s teljes lersa.
Az vek sorn a programtervezs slypontja az eljrsok fell az adatszervezs irnyba toldott el. Ez
leginkbb a programok egyre nagyobb mretben tkrzdtt. Az egymssal rokon eljrsokat az ltaluk
kezelt adatokkal egytt modul-nak nevezzk. A modulris programozsi elv mr nem elssorban a fgg-
vnyekre s azok paramtereinek tadsra koncentrl. Az alapelve valahogy gy fogalmazhat meg:
Dntsd el, mely modulokra van szksg s oszd fel a programot gy, hogy az adatokat modulokba he-
lyezd.. Ez tulajdonkppen az adatrejts elve. A modularits alapvet szempont minden sikeres nagy
programnl.
A modularits s az elvont adatbrzols (sajt tpusokkal) a j tervezshez alapfontossg. A felhaszn-
li (ltalunk ltrehozott tpusok) azonban nmagukban nem elg rugalmasak ahhoz, hogy kiszolgljk
ignyeinket.
A C++ ersen tmogatja az objektumorientlt programozst is (OOP). Ez a programozsi paradigma ma
mr szinte egyeduralkod. Az OOP-t hasznlva mr elg jl lehet tervezni ahhoz, hogy nagymret

5
szoftvereket is kpesek legynk jl megrni. Az objektumorientltsgrl bvebben ebben a jegyzetben
nem lesz sz.
A C++ ezek alapjn egy multi-paradigma programozsi nyelvnek mondhat, mivel az elbb emltett pa-
radigmkat mind alkalmazhatjuk.
A magas szint programozsi nyelvek (gy a C++ is) viszonylag gpfggetlenek, sok utastssal rendel-
keznek, s tbbsgk sszetett feladatokat kpes megvalstani. Az utastsok ltalban angol szavak,
vagy azok rvidtseiknt adhatk meg. A programozs olyan folyamat, amely sorn egy feladat megol-
dst a szmtgp szmra rthet mdon rjuk le (0-k s 1-ek sorozata). A programozsi nyelv a
programozskor hasznlt lers nyelve. A program a programozs eredmnyeknt jn ltre, utastsok
sorozatbl pl fel. A forrs program a megrt programszveg, amelyet valamilyen szvegszerkesztvel
hoztunk ltre.
Fordt program (compiler) a programot a szmtgp szmra lefordtja, azaz a forrsprogramot egy
gynevezett trgyprogramm alaktja. A fordtsi egysg a nyelvnek az az egysge, ami a fordtprogram
egyszeri lefuttatsval, a program tbbi rsztl elklnlten lefordthat, gy nem kell mindig a teljes
programot jrafordtani. Egy fordtsi egysg tbb fjlbl is llhat. A fordts sorn a fordts lpsei sor-
rendben az elfordts, fordts s a linkels. Ekkor a forrskdbl a gp szmra rtelmezhet gpi kd
keletkezik. Az egyes lpsek nem klnlnek el felttlenl egymstl, teht pldul az elfordt nem
generl le egy klnll fjlt, hanem a kimenett azonnal tadja a fordtnak.
Az elfordt (preprocessor) klnbz szveges vltoztatsokat hajt vgre a forrskdon, elkszti
azt a tnyleges fordtsra. Feladatai a kvetkezk:
header (fejlc) fjlok beszrsa
a forrsfjlban fizikailag tbb sorban elhelyezked forrskd logikailag egy sorba trtn csopor-
tostsa (ha szksges)
kommentek helyettestse whitespace karakterekkel
az elfordtnak a programoz ltal megadott feladatok vgrehajtsa
Header file a fejllomnyok tpusokat, valamint a vltozk s fggvnyek deklarciit tartalmazzk.
Whitespace karakter a program szvegt n. whitespace karakterek trdelik szt. Ilyennek szmt maga
a szkz, a tabultor, s a sorvge jel. A programozsi nyelvek szintaktikja ltalban gy fogalmaz,
hogy ahol llhat egy whitespace karakter, ott llhat tbb is.
Az elfordt (preprocessor) a tnyleges fordtprogram futsa eltt szvegesen talaktja a forrs-
kdot. A ketts kereszttel (#) kezdd sorok az elfordtnak szl utastsok. Pldul:
#include <iostream> - fjl beilleszts
A C++ a knyelmes s hatkony input/output kezels rdekben gynevezett adatfolyamokat
(streameket) hasznl. Teht egysges mdon kezelhetjk a kirst s beolvasst kpernyre, billen-
tyzetre, fjlokba vagy brmilyen ms I/O eszkzre. Alapvet adatfolyam objektumok:
iostream I/O utastsokat tartalmaz a kiratshoz
fstream megknnyti a fjlmveleteket
A C++ programozsi nyelvben egy j szolgltats ll a programozk rendelkezsre nagy rendszerek
ksztshez, ez a nvtr. A nvtr egy hierarchikus programobjektum-azonost trolsi struktra.
Azaz, a logikailag sszetartoz deklarcik csoportostsa. A programobjektumok elhelyezse a nvte-
rekben egyszer. A keressi tvonal programozhat, megadsa a using utastssal trtnik. A megkez-
dett nvtr folytathat, a folytatsok szma nincs korltozva. Plda a standard nvtr hasznlatra:
using namespace std
A C++ nyelvben a szabvnyos I/O mveletek vgzsre hasznlt cin s cout adatfolyam (stream) ob-
jektumok nem rszei a C++ nyelv defincijnak. A C++ szabvny minden knyvtri elemet egy kzs
std (standard) nvterleten definil. A szabvnyos outputknt a cout, a szabvnyos input elvgzsre

6
pedig a cin adatfolyam-objektumot hasznljuk. A << s >> jelek az adatfolyam irnyt jelzik. A szveg
kirsa "" kztt trtnik. Pl.
cout << "Elso programunk" a szveg a kimenetre (kpernyre) kerl
cin >> n a konzolrl (billentyzet) az n vltozba (lsd ksbb)
A program rsakor megjegyzseket is elhelyezhetnk, melyeket nem vesz figyelembe a fordt. Ktfle
mdon tehetjk meg ezeket:
/* */ kztt tbbsoros megjegyzs elhelyezse
// hasznlatval pedig a sor vgig terjed megjegyzst adhatunk meg
// egysoros megjegyzs
/* tbbsoros
megjegyzs*/
3. A C++ nyelv alapelemei
Az alapelemek nevek, szmok s karakterek, melyekbl a C++ program felpl. Ezeket az elemeket
tokennek nevezzk. A C++ forrsprogram fordtsakor a fordtprogram a nyelv tokenjeit dolgozza fel
(a tokeneket a fordtprogram mr nem bontja tovbbi rszekre). A C++ nyelv alapelemeihez tartoznak a
kulcsszavak, az azonostk, a konstansok, a sztringliterlok, az opertorok s az rsjelek (lsd ksbb).
a) A C++ nyelv jelkszlete
A szabvnyos C++ program ksztsekor ktfle jelkszlettel dolgozunk. Az els jelkszlet azokat a ka-
raktereket tartalmazza, amelyekkel a C++ programot megrjuk:
A B C D E F G H I J
K L M N O P Q R S T
U V W X Y Z
a b c d e f g h i j
k l m n o p q r s t
u v w x y z
! " # % & ' ( ) * +
, - / : ; < = > ? [
\ ] ^ _ { | } ~
A nem lthat karakterek kzl ide tartoznak mg a szkz, a vzszintes s fggleges tabultor, a sor-
emels s a lapdobs karakterek is, melyek feladata a forrsszveg tagolsa. (ezeket a karaktereket ssze-
foglal nven white-space karaktereknek hvjuk.) Azok a karakterek (ANSI, UniCode) melyeket nem
tartalmaz a C++ nyelv karakterkszlete, szintn szerepelhetnek a programban, de csak megjegyzsek s
sztringliterlok (szveg konstansok) belsejben.
b) A C++ nyelv azonosti
A C++ nyelv program bizonyos sszetevire (pl. vltozkra, fggvnyekre, cmkkre,...) nvvel hivat-
kozunk. A nevek megfelel megvlasztsa lnyeges rsze a program rsnak. Az azonostk hossza
megvalsts fgg, a legtbb fordt legfeljebb 32 karakteres nevek hasznlatt tmogatja. Az azonost
els karaktere bet vagy _ (alhzs jel) lehet, mg a msodik karaktertl kezdden betk, szmok s
alhzs jelek vlthatjk egymst. Az azonostk elejn az alhzs jel ltalban a rendszer ltal hasznlt,
illetve a C++ nyelv bvtst jelent nevekben szerepel. A legtbb programozsi nyelvtl eltren a C++
nyelv az azonostkban megklnbzteti a kis- s a nagybetket. Ezrt az albbi nevek egymstl fgget-
lenl hasznlhatk a programban (nem azonosak):
alma, Alma, ALMA
Elterjedt konvenci, hogy kisbetvel rjuk a C++ azonostkat s csupa nagybetvel az elfordt ltal
hasznlt neveket. Pldul:
byte, TRUE, FALSE
7
Az rtelmes szavakbl sszelltott azonostkban az egyes szavakat ltalban nagybetvel kezdjk:
FelsoSarok, XKoordinata
Bizonyos azonostk specilis jelentst hordoznak. Ezeket a neveket foglalt szavaknak vagy kulcsszavak-
nak nevezzk. A foglalt szavakat a programban csak a hozzjuk rendelt rtelmezsnek megfelelen lehet
hasznlni. A kulcsszavakat nem lehet tdefinilni, j jelentssel elltni. Az albbi tblzatban sszefoglal-
tuk az ANSI C++ nyelv kulcsszavait:
asm do inline return try
auto double int short typedef
bool dynamic_cast long signed typeid
break else mutable sizeof typename
case enum namespace static union
catch explicit new static_cast unsigned
char extern operator struct using
class false private switch virtual
const float protected template void
const_cast for public this volatile
continue friend register throw wchar_t
default goto reinterpret_cast true while
delete if
A legtbb fordtprogram kibvti a szabvnyos kulcsszavakat sajt jelentssel br szavakkal. Erre a
C++ szabvny a kt alhzs jel hasznlatt javasolja, pldul:
__try, __property, __published
c) Konstansok
A C++ nyelv megklnbzteti a numerikus s a szveges konstansrtkeket. A konstansok alatt mindig
valamifle szmot rtnk, mg a szveges konstansokat sztringliterlnak hvjuk. A konstans rtkek ilyen
megklnbztetst a trolsi s felhasznlsi mdjuk indokolja. A C++ nyelvben karakteres, logikai,
egsz, felsorolt s lebegpontos konstansokat hasznlhatunk.
A C++ nyelv logikai konstansai az igaz rtket kpvisel true s a hamis rtk false. A nyelv egyet-
len mutat konstanssal rendelkezik a nullval (0), melyet gyakran a NULL szimblummal jellnk.
Egsz konstansok az egsz konstansok szmjegyek sorozatbl llnak. A szmjegyek decimlis (10-
es), oktlis (8-as) vagy hexadecimlis (16-os) szmrendszerbeli jegyek lehetnek. Az egsz konstansok,
amennyiben nem elzi meg ket negatv (-) eljel, pozitv rtkeket jellnek.
Karakter konstansok az ANSI (egybjtos) karakter konstansok egyszeres idzjelek ( ' - aposztrf)
kz zrt egy karaktert tartalmaz konstansok.Pl. 'a', '2', '@'
Bizonyos szabvnyos vezrl- s specilis karakterek megadsra az n. escape szekvencikat hasz-
nlhatjuk. Az escape szekvenciban a fordtott osztsjel (backslash - \) karaktert specilis karakterek,
illetve szmok kvetik, mint ahogy az a kvetkez tblzatbl is lthat.
rtelmezs ASCII karakter Escape szekvencia
cseng BELL '\a'
visszatrls BS '\b'
lapdobs FF '\f'
jsor NL (LF) '\n'
kocsi-vissza CR '\r'
vzszintes tabulls HT '\t'
fggleges tabulls VT '\v'
aposztrf ' '\''
idzjel " '\"'
backslash \ '\\'
krdjel ? '\?'
8
 Lebegpontos konstansok a lebegpontos konstans olyan decimlis szm, amely eljeles vals sz-
mot reprezentl. A vals szm ltalban egsz rszbl, tizedes trtrszbl s kitevbl tevdik ssze.
Az egsz- s trtrszt tizedespont (.) kapcsolja ssze, mg a kitev (10 hatvnykitevje) az e, vagy az
E bett kveti.
Pl. .1, -2., 100.45, 2e-3, 11E2, -3.1415
A C++ nyelvben a lebegpontos rtkek a trolsukhoz szksges memriaterlet mrettl fggen -
ami a trolt vals szm pontossgt s nagysgrendjt egyarnt meghatrozza - lehetnek egyszeres
(float), ktszeres (double) vagy nagy (long double) pontossg szmok. A lebegpontos konstansok
alaphelyzetben dupla pontossg rtkek. Vannak esetek, amikor megelgsznk egyszeres pontossg
mveletekkel is, ehhez azonban a konstansokat is egyszeres pontossgknt kell megadni a szmot
kvet f vagy F betk felhasznlsval.
Pl. 3.1415F, 2.7182f
Nagy pontossg szmtsok elvgzshez nagy pontossg lebegpontos konstansokat kell definil-
nunk az l (kis L) vagy az L bet segtsgvel.
Pl. 3.1415926535897932385L, 2.7182818284590452354l
Sztringkonstansok (literlok) az ANSI sztringliterl, amit sztringkonstansnak is szoks hvni, ketts
idzjelek kz zrt karaktersorozatot jelent.
Pl. "Ez egy sztring konstans"
A megadott karaktersorozatot a statikus memriaterleten helyezi el a fordt, s ugyancsak eltrolja a
sztringet zr '\0' karaktert (nulls byte-ot) is. A sztringkonstans tartalmazhat escape szekvencikat is.
Pl. "\nElso sor!\Masodik sor!\n"
d) Megjegyzsek
A megjegyzsek olyan karaktersorozatok, melyek elhelyezsnek clja, hogy a program forrskdja jl
dokumentlt, ezltal egyszeren rtelmezhet, jl olvashat legyen. A C++ nyelvben a megjegyzsek
programban trtn elhelyezsre /* ... */ jeleken kvl a // (kt perjel) is hasznlhat. A // jel hasznlata
esetn a megjegyzst nem kell lezrni, hatsa a sor vgig terjed.
Pl. //egysoros megjegyzs
/* tbbsoros megjegyzs els sora
msodik sora
harmadik sora*/
e) Opertorok s rsjelek
Az opertorok olyan egy vagy tbb karakterbl ll szimblumok, melyek megmondjk, hogyan kell fel-
dolgozni az operandusokat. A kvetkez tblzatban minden magyarzat nlkl felsoroljuk a C++ nyelv
(szabvnyos) opertorait.
! != % %= & && &= () * *=
+ ++ += - -- -= -> . /
/= < <= << <<= = == > >= >>
>>= ?: [] ^ ^= sizeof | |= || ~
:: .* ->* new delete

9
Az rsjelek a C++ nyelvben olyan szimblumokat jellnek, amelyeknek csak szintaktikai szerepe van.
Az rsjeleket ltalban azonostk elklntsre, a programkd egyes rszeinek kijellsre hasznljuk,
s semmilyen mveletet sem definilnak. Nhny rsjel egyben opertor is.
rsjel Az rsjel szerepe
[] Tmb kijellse, mretnek megadsa
() A paramter-s az argumentum lista kijellse
{} Kdblokk vagy fggvny behatrolsa
* A mutat tpus jellse a deklarciban
A fggvny argumentumok elvlasztsa
: Cmke elvlasztsa
; Az utasts vgnek jellse
Vltoz hosszsg argumentumlista jellse
# Elfordt direktva jellse
4. C++ program szerkezete
A C++ nyelven megrt program egy vagy tbb forrsfjlban (fordtsi egysgben, modulban) helyezkedik
el, melyek kiterjesztse ltalban .cpp. A programhoz ltalban n. deklarcis (include, header, fej-)
llomnyok is csatlakoznak, melyeket az #include elfordt utasts segtsgvel ptnk be a forrs-
llomnyokba.
a) Egyetlen modulbl felpl C++ program
A C++ program fordtshoz szksges deklarcikat a main() fggvnnyel azonos forrsfjlban, de
tetszleges szm ms forrsllomnyban is elhelyezhetjk. A main() fggvny kitntetett szerepe ab-
ban ll, hogy kijelli a program belpsi pontjt, vagyis a program futsa a main() fggvny indtsval
kezddik. Ezrt rthet az a megkts, hogy minden C++ programnak tartalmaznia kell egy main()
nev fggvnyt, de csak egy pldnyban. A legegyszerbb C++ program egyetlen res main() fggvny:
int main()
{
return 0;
}
int a fggvny tpusa
main a fggvny neve
() a fggvnynek nincs paramtere
return 0; a fggvny trzse, az utastsokat pontosvesszvel kell lezrni
0 visszatrsi rtk
{} a fggvny trzst befoglal zrjelek
b) Tbb modulbl ll C++ program
A C++ nyelv tartalmaz eszkzket a modulris programozs elvnek megvalstshoz. A modulris
programozs lnyege, hogy minden modul nll fordtsi egysget kpez, melyeknl rvnyesl az adat-
rejts elve. Mivel a modulok kln-kln lefordthatk, nagy program fejlesztse, javtsa esetn nem
szksges minden modult jrafordtani. Ez a megolds jelentsen cskkenti a futtathat program elll-
tsnak idejt.
A futtathat fjl ellltsakor minden modult kln le kell fordtanunk. A keletkez trgymodulokat a
szerkeszt (linker) pti ssze a megfelel knyvtri hivatkozsok feloldsval. ltalban elmondhat,
hogy a C++ forrsprogram elfordt utastsok, deklarcik s defincik, utastsblokkok s fggv-
nyek kollekcija.
5. A C++ alaptpusai, vltozk, konstansok
A C++ nyelvben minden felhasznlt nvrl meg kell mondanunk, hogy mi az, s hogy mire szeretnnk
hasznlni. E nlkl a fordt ltalban nem tud mit kezdeni az adott nvvel. A C++ nyelv szhasznlat-
10
val lve mindig deklarlnunk kell az ltalunk alkalmazni kvnt neveket. A deklarci (lers) sorn csak
a nv tulajdonsgait (tpus, trolsi osztly, lthatsg stb.) kzljk a fordtval. Ha azonban azt szeret-
nnk, hogy az adott deklarcinak megfelel memriafoglals is vgbemenjen, defincit kell hasznl-
nunk. A definci teht olyan deklarci, amely helyfoglalssal jr. Ugyanazt a nevet tbbszr is dekla-
rlhatjuk, azonban az egyms kvet deklarciknak egyeznik kell. Ezzel szemben valamely nv defin-
cija csak egyetlenegyszer szerepelhet a programban. A fordt szmra a deklarci (definci) sorn
kzlt egyik legfontosabb informci a tpus.
a) A C++ nyelv tpusai
A C++ nyelv tpusait tbbflekppen csoportosthatjuk. Egyik szempont szerint beszlhetnk alaptpu-
sokrl s szrmaztatott tpusokrl.
Alaptpusok karakter (char), egsz (int) s lebegpontos (double) tpus
Szrmaztatott tpusok az alaptpusok felhasznlsval felptett tmb, fggvny, mutat, osztly,
struktra s uni tpus
Void tpus nem meghatrozott tpus
Az alaptpusokhoz tartoz char, int s double tpuselrsokhoz bizonyos ms kulcsszavakat (tpusmdo-
stkat) kapcsolva, jabb tpuselrsokhoz jutunk, amelyek rtelmezse eltr a kiindulsi elrstl. A
tpusmdostk a hatsukat ktfle mdon fejtik ki. A short s a long mdostk a trolsi hosszat, mg a
signed s az unsigned az eljel rtelmezst szablyozzk.
A tpus egy nv vagy kifejezs megfelel hasznlatt hatrozza meg. A C++ tbb alaptpussal rendelke-
zik, melyek kzvetlen megfeleli bizonyos hardverszolgltatsoknak.
Nv Tpus Lehetsges rtkek
bool (logikai) logikai true/false (igaz/hamis)
char (karakter) karakter Pl.: 'a', 'b', , 'Z', ...
int (egsz) egsz Pl.: 1, 2, 16, 314, ...
short int vagy short (rvid egsz) egsz Pl.: 1, 2, 16, 314, ...
long int vagy long (hossz egsz) egsz Pl.: 1, 2, 16, 314, ...
float (vals) vals Pl.: 3,14,
double (duplapontos vals) vals Pl.: 299793,0
long double (hossz duplapontos vals) vals Pl.: 299793,0
wchar_t szabad karakter Pl.: s
b) Egyszer vltozk definilsa
A C++ program memriban ltrehozott trolit nvvel ltjuk el, hogy tudjunk rjuk hivatkozni. A nv
segtsgvel a trolhoz rtket rendelhetnk, illetve lekrdezhetjk az eltrolt rtket. A nvvel elltott
trolkat a programozsi nyelvekben vltoznak szoks nevezni.
Pl. int konyv;
int n;
int alma, korte;
int tomb[5];
c) Konstansok a C++ nyelvben
A C++ nyelvben tbbfle mdon hasznlhatunk konstansokat. Az els lehetsg a const tpusminst
megadst jelenti a vltozdefinciban. A vltozk rtke ltalban megvltoztathat.
Pl. int a;
a=9;

11
Ha azonban a definciban szerepel a const kulcssz, a vltoz csak olvashat lesz, vagyis rtkt nem
lehet kzvetlenl megvltoztatni. Ekkor a definciban ktelez a kezdrtk megadsa.
Pl. const int a=15;
d) rtkek
A vltozk ltalban az rtkads sorn kapnak rtket, melynek ltalnos alakja:
vltoz = rtk;
A C++ nyelven az rtkads opertor s a fenti utasts valjban egy kifejezs, amit a fordtprogram
rtkel ki. Az rtkads opertornak bal- s jobb oldaln egyarnt szerepelhetnek kifejezsek, melyek
azonban lnyegileg klnbznek egymstl. A baloldalon szerepl kifejezs azt a vltozt jelli ki (cmzi
meg) a memriban, ahova a jobb oldalon megadott kifejezs rtkt be kell tlteni.
A fenti alakbl kiindulva a C++ nyelv kln nevet ad a ktfajta kifejezsnek. Annak a kifejezsnek az
rtke, amely az egyenlsgjel bal oldaln ll, a balrtk (lvalue), mg a jobboldalon szerepl kifejezs
rtke a jobbrtk (rvalue). Vegynk pldaknt kt egyszer rtkadst:
Pl. int a;
a = 12;
a = a + 1;
Az els rtkads sorn az a vltoz, mint balrtk szerepel, vagyis a vltoz cme jelli ki azt a trolt,
ahova a jobboldalon megadott konstans rtket be kell msolni. A msodik rtkads sorn az a vltoz
az rtkads mindkt oldaln szerepel. A baloldalon ll a ugyancsak a trolt jelli ki a memriban
(lvalue), mg a jobboldalon ll a egy jobbrtk kifejezsben szerepel, melynek rtkt (13) a fordt
meghatrozza az rtkads elvgzse eltt.
6. Opertorok s kifejezsek
Az eddigiek sorn gyakran hasznltunk olyan utastsokat (mint pldul az rtkads), amelyek pontos-
vesszvel lezrt kifejezsbl lltak. A kifejezsek egyetlen operandusbl, vagy az operandusok s a m-
veleti jelek (opertorok) kombincijbl plnek fel. A kifejezs kirtkelse valamilyen rtk kiszm-
tshoz vezethet, fggvnyhvst idzhet el vagy mellkhatst (side effect) okozhat. Az esetek tbbsg-
ben a fenti hrom tevkenysg valamilyen kombincija megy vgbe a kifejezsek feldolgozsa (kirt-
kelse) sorn.
Az operandusok a C++ nyelv azon elemei, amelyeken az opertorok fejtik ki hatsukat. Azokat az ope-
randusokat, amelyek nem ignyelnek tovbbi kirtkelst elsdleges (primary) kifejezseknek nevezzk.
Ilyenek az azonostk, a konstans rtkek, a sztringliterlok s a zrjelben megadott kifejezsek. Ha-
gyomnyosan az azonostkhoz soroljuk a fggvnyhvsokat, valamint a tmbelem- s a struktra taghi-
vatkozsokat is.
A kifejezsek kirtkelse sorn az opertorok lnyeges szerepet jtszanak. Az opertorokat tbb szem-
pont alapjn lehet csoportostani. A csoportostst elvgezhetjk az operandusok szma szerint. Az egy-
operandus (unary) opertorok esetn a kifejezs ltalnos alakja:
operator operandus prefixes alak pl. a, sizeof(a)
operandus operator postfixes alak pl. a++
Az opertorok tbbsge kt operandussal rendelkezik, ezek a ktoperandus (binary) opertorok:
operandus1 operator operandus2 pl. a+b, a<<2, a+=b
A C++ nyelvben egyetlen hromoperandus opertor, a feltteles opertor hasznlhat:
a < 0 ? a : a

12
Az albbi tblzatban a C++ nyelv mveleteit csoportostottuk:
Preced Asszoci-
Opertor Rvid lers Jells
encia ativits
1 :: Hatkr-felolds nincs a::b, ::b
() Csoportosts (a)
[] Tmb-elrs a[]
-> Mutatn keresztli tag-elrs ptr->b()
2 Bal
. Objektumon keresztli tag-elrs a.b()
++ Posztfix nvels a++
-- Posztfix cskkents a--
! Logikai tagads !a
~ Bitenknti negls ~a
++ Prefix nvels ++a
-- Prefix cskkents --a
- Eljel - -a
3 Jobb
+ Eljel + +a
* Dereferls *ptr
& Objektum cme &a
(tpus) Konverzi tpusra (tpus)a
sizeof Mret sizeof(a)
->* a->*b()
4 Tagkivlaszts mutatn/objektumon Bal
.* a.*b()
* Szorzs a*b
5 / Oszts Bal a/b
% Maradkszmts a%b
+ sszeads a+b
6 Bal
- Kivons a-b
<< Bitenknti eltols balra a<<const
7 Bal
>> Bitenknti eltols jobbra a>>const
< Kisebb a<b
<= Kisebb-egyenl a<=b
8 Bal
> Nagyobb a>b
>= Nagyobb-egyenl a>=b
== Egyenl a==b
9 Bal
!= Nem egyenl a!=b
10 & Bitenknti S Bal a&b
11 ^ Bitenknti kizr VAGY Bal a^b
12 | Bitenknti megenged VAGY Bal a|b
13 && Logikai S Bal a&&b
14 || Logikai(megenged) VAGY Bal a||b
log. kif.
?
15 ?: if-then-else opertor Jobb kifejezs
:
kifejezs

13
 = rtkads a=b
+= sszeads s rtkads a+=b
-= Kivons s rtkads a_=b
*= Szorzs s rtkads a*=b
/= Oszts s rtkads a/=b
16 %= Maradkkpzs s rtkads Jobb a%=b
&= Bitenknti S s rtkads a&=b
^= Bitenknti kizr VAGY s rtkads a^=b
|= Bitenknti megenged VAGY s rtkads a|=b
<<= Eltols balra s rtkads a<<=b
>>= Eltols jobbra s rtkads a>>=b
17 , Szekvencia opertor Bal a, b
Az opertorok precedencija (elsbbsge) akkor jtszik szerepet a kifejezs kirtkelse sorn, ha a kife-
jezsben klnbz precedencij mveletek szerepelnek. Ekkor mindig a magasabb precedencival ren-
delkez opertort tartalmaz rszkifejezs kerl elszr kirtkelsre, amit az alacsonyabb precedencij
mveletek vgrehajtsa kvet.
Pl. 5 + 3 * 4 = 17 a szorzs ersebb mvelet, mint az sszeads
(5 + 3) * 4 = 32 a zrjelben lv mvelet elszr
Egy kifejezsben tbb azonos precedencij mvelet is szerepelhet. Ebben az esetben az opertortblzat
csoportnevei mellett tallhat tmutatst kell figyelembe venni a kirtkels sorn, hisz a precedencia
szably nem alkalmazhat. Az asszociativits azt mondja meg, hogy az adott precedenciaszinten tallhat
mveleteket balrl-jobbra vagy jobbrl-balra haladva kell elvgezni.
Az rtkad utastsok csoportjban a kirtkelst jobbrl-balra haladva kell elvgezni. Emiatt C++-ban
adott a lehetsg tbb vltoz egyttes inicializlsra.
Pl. int a,b,c;
a = b = c = 26;
7. A C++ nyelv utastsai
A C++ nyelven megrt program vgrehajthat rsze elvgzend tevkenysgekbl (utastsokbl) pl
fel. Az utastsok a strukturlt programozs alapelveinek megfelelen ciklusok, programelgazsok s
vezrlstadsok szervezst teszik lehetv. A C++ nyelv ms nyelvekhez hasonlan rendelkezik a
vezrlstads goto utastsval, melynek hasznlata nehezen kvethetv teszi a program szvegt. Ezen
utasts hasznlata azonban az esetek tbbsgben elkerlhet a break s a continue utastsok bevezet-
svel. A C++ nyelv utastsait ht csoportba sorolhatjuk:
Kifejezs utasts
res utasts ;
sszetett utasts {}; try{}
Szelekcis utastsok if, else, switch
Cmkzett utastsok case, default, ugrsi cmke
Vezrlstad utastsok break, continue, goto, return, throw
Itercis utastsok (ciklusok) do, for, while
Tetszleges kifejezs utasts lesz, ha pontosvesszt helyeznk mg:
kifejezs;
A kifejezs utasts vgrehajtsa a kifejezsnek az elzekben ismertetett szablyok szerint trtn kir-
tkelst jelenti. Mieltt a kvetkez utastsra kerlne a vezrls, a teljes kirtkels vgbemegy.
Az res utasts egyetlen pontosvesszbl ll: ;

14
Az res utasts hasznlatra akkor van szksg, amikor logikailag nem kvnunk semmilyen tevkenys-
get vgrehajtani, azonban a szintaktikai szablyok szerint a program adott pontjn utastsnak kell szere-
pelnie. Az res utastst, melynek vgrehajtsakor semmi sem trtnik, gyakran hasznljuk a do, for,
while s if szerkezetekben.
A kapcsos zrjeleket hasznljuk arra, hogy a logikailag sszefgg deklarcikat s utastsokat egyet-
len sszetett utastsba vagy blokkba csoportostsuk. Az sszetett utasts mindentt felhasznlhat, ahol
egyetlen utasts megadst engedlyezi a C++ nyelv lersa. sszetett utastst a kvetkez hrom eset-
ben hasznlunk:
Amikor tbb logikailag sszefgg utastst egyetlen utastsknt kell kezelni (ilyenkor ltalban
csak utastsokat tartalmaz a blokk)
Fggvnyek trzseknt
Defincik s deklarcik rvnyessgnek lokalizlsra
Az utastsblokkon bell az utastsokat s a defincikat/deklarcikat tetszleges sorrendben megadhat-
juk. A blokkot nem kell pontosvesszvel lezrni. Az sszetett utasts ltalnos formja:
{
loklis defincik s deklarcik
utastsok
}
a) Szabvnyos be- s kimenet utastsok
Egy program sorn szksgnk lehet adatok kirsra vagy bekrsre a felhasznltl. A C++ Stan-
dard Library rsze az iostream knyvtr. Segtsgvel minden beptett tpusra meghatroz kimenetet
(pl. ki tudunk rni szvegeket, egsz s lebegpontos szmokat is), de lehetsgnk van sajt, ltalunk
ltrehozott tpusokra is megadni a kimeneteiket. Alaprtelmezettknt a cout ra kerl kimenetek ka-
raktersorozatokk alaktdnak t, ami a kpernyre rdik ki.
A cout szabvnyos kimeneti adatfolyam. A << opertorral tudunk egyszeren a kpernyre rni.
Ezt felfoghatjuk akr tedd bele opertorknt is.
Pl. cout << kifejezs1 << kifejezs2;
A klnbz tpus kimenetek termszetesen prosthatk is, tovbb egy kimeneti kifejezs eredm-
nye felhasznlhat tovbbi kimenetekhez is. Ez gyakorlatilag annyit jelent, hogy szpen, lncba kt-
hetjk ket. (ahogy az elbbi pldban is lthat).
A karakter konstans egy karakter, egyszeres idzjelek kz zrva. (pl: a). Karakterlnc konstanst is
hasznlhatunk, melyeket idzjelek kz kell zrni (pl.: Krem, adjon meg egy egsz szmot!).
Az albbi pldban deklarltunk egy egsz, s kett szveges tpus vltozt, majd klnbz kirat-
sokat vgeztnk karakterrel, szmmal, szveggel s a vltozkkal (eltte behvtuk a string osztlyt -
#include <string>). A 16. sorban lthatjuk, hogy szvegeket ssze lehet fzni a + opertorral.
A 17. sorban pedig azt lthatjuk, hogy egy szveghez hozz lehet fzni tetszleges szveget a += ope-
rtorral. Ezen kvl a \n escape karakterrel elrjk, hogy a kirsok j sorban kezddjenek.

15
Formzott kirsokat az escape karakterekkel tehetnk. Szvegek esetn vzszintes tabultorokkal, j
sorba rssal rhetnk el formzott elrendezseket. Az albbi pldban nhny lehetsget ltunk:

A 6. s 7. sorban kt tabultort helyeztnk el, mert a 8. sorban lv Both Peach szveg hosszabb az
alaprtelmezett tabultornl. Azt is szrevehetjk, hogy a 8. sorban nem a \n escape karakterrel rtunk
j sorba, hanem az endl (end line vge a sornak) utastssal.
Tovbbi megjelentsi lehetsgek vannak, ezekhez azonban be kell hvni az iomanip osztlyt.
#include <iomanip>

16
Az albbi pldban nhny egyszer kirsi megoldst szemlltetnk a teljessg ignye nlkl. A
hasznlt manipultorok a kvetkezk:
left, right: balra, jobbra igazts
setw(): a kirs szlessgnek megadsa
setfill(): kitlt karakter megadsa
dec, oct, hex: tzes, nyolcas, tizenhatos szmrendszerbeli alak
setprecision: tizedes jegyek szmnak megadsa
fixed: tizedes trt alak
scientific: exponencilis alak (hatvnyalak)

Beolvass szabvnyos bemenetrl (cin) a cin szabvnyos bemeneti adatfolyam. A >> (olvasd be)
mveleti jelet bemeneti opertorknt hasznljuk. A >> jobb oldaln ll tpus hatrozza meg, milyen
bemenet fogadhat el, s mi a beolvas mvelet clpontja.

17
 Nzznk egyszer pldt bevitelekre:

b) Az if utasts
A C++ nyelv kt lehetsget biztost a program kdjnak felttelhez kttt vgrehajtsra - az if s a
switch utastsokat. Az if utasts segtsgvel valamely tevkenysg (utasts) vgrehajtst egy kife-
jezs (felttel) rtktl tehetjk fggv. Az if albbi formjban az utasts csak akkor hajtdik vg-
re, ha a kifejezs rtke nem nulla (igaz true).
Fontos megjegyezni, hogy C++ esetn az if-ben az rtknek egy szmnak kell lennie. 0 esetn hamis,
egyb esetben pedig igaznak rtkeli ki. C++ -ban br ltezik logikai rtk, a bool tpus (boolean),
azonban ez nem valdi logikai rtk. A bool true-ja 1-esnek, a false-a pedig 1-nek felel meg. Azrt van
gy a nyelvben, mert a C++ egy, a C-bl ered alacsonyabbnak szmt nyelv. Magasabb szint nyel-
vekben (pldul Java, C#, stb.) ltezik kln logikai, boolean tpus. Azoknak az rtkei nem feleltethe-
tek meg szmoknak, s egy if-ben szerepl kifejezs csak s kizrlag logikai tpus lehet, klnben
fordtsi idej hibt kapunk. C++ -ban ezzel ellenttben akrmi lehet a kifejezs rtke az if-ben, hi-
szen mindent egy szmknt rtkel ki. gy a kifejezs rtke lehet egy a karakter is. Ez esetben kike-
resi az a ASCII kdjt, s azt vizsglja, hogy nulla-e. Mint azt az elbb megbeszltk, nulla esetn
hamis, egyb esetben pedig igaz.
18
 Nzznk egy egyszer pldt az if hasznlatra:

c) Az if-else szerkezet
Az if utasts teljes formjban, amely tartalmazza az else gat, arra az esetre is megadhatunk egy te-
vkenysget (utasts2), amikor a kifejezs (felttel) rtke hamis (false). Ha az utasts1 s az
utasts2 nem sszetett utastsok, akkor pontosvesszvel kell ket lezrni.
if (kifejezs)
utasts1;
else
utasts2;
Nzznk erre a szerkezetre is egy egyszer pldt.

19
d) Egymsba gyazott if utastsok
Az if utastsok egymsba is gyazhatk. Ilyenkor azonban vatosan kell eljrnunk, hisz a fordt nem
mindig gy rtelmezi az utastst, ahogy mi gondoljuk (a fordt minden if utastshoz a hozz legk-
zelebb es else utastst rendeli). Egy jrhat t, ha a bels if utastst kapcsos zrjelek kz, azaz
utasts blokkba helyezzk.
Nzznk erre is egy egyszer pldt. Ha a megadott szm 30-nl nagyobb, akkor megnzzk mg azt
is, hogy pros szm, vagy nem. Ezt a maradkos osztssal (%) tudjuk megllaptani (==, egyenl), az-
az, ha 2-vel osztva a maradk nulla, akkor pros szmrl van sz. Ha a szm nem nagyobb 30-nl, ak-
kor tovbbi vizsglat nincs, kirjuk, hogy a szm nem nagyobb 30-nl.

e) Az else-if szerkezet
Az egymsba gyazott if utastsok gyakran hasznlt formja, amikor az else gakban szerepel az
jabb if utasts. Ezzel a szerkezettel a program tbbirny elgaztatst valsthatjuk meg. Ha br-
melyik kifejezs igaz, akkor a hozzkapcsolt utasts kerl vgrehajtsra. Amennyiben egyik felttel
sem teljeslt, a program vgrehajtsa az utols else utastssal folytatdik.

20
f) A switch utasts
A switch utasts tbbirny programelgaztatst tesz lehetv olyan esetekben, amikor egy egsz ki-
fejezs rtkt tbb konstans rtkkel kell sszehasonltanunk. Az utasts ltalnos alakja:
switch (kifejezs)
{
case konstans_kifejezs:
utastsok
case konstans_kifejezs:
utastsok
default:
utastsok
}
A switch utasts elszr kirtkeli a kifejezst, majd tadja a vezrlst arra a case cmkre (esetre),
amelyben a konstans_ kifejezs rtke megegyezik a kirtkelt kifejezs rtkvel s a program futsa
ettl a ponttl folytatdik. Amennyiben egyik case konstans sem egyezik meg a kifejezs rtkvel, a
program futsa a default cmkvel megjellt utaststl folytatdik. Ha nem hasznlunk default cm-
kt, akkor a vezrls a switch utasts blokkjt zr kapcsos zrjel utni utastsra addik.
Amikor a case vagy a default cmkvel belpnk a switch utasts trzsbe, akkor attl a ponttl
kezdve a megadott utastsok sorban vgrehajtdnak (a blokkot zr zrjel elrsig). ltalban
azonban az adott esethez tartoz programrszlet vgrehajtsa utn a goto, a break vagy a return utas-
tssal kilpnk a switch utastsbl. Amennyiben a switch utasts utn ll utastssal kvnjuk foly-
tatni a program futst, akkor a break utastst hasznljuk.
Nzznk pldt a switch utastsra. A programban kt pldt is lthatunk, az els esetben a bert egsz
szmtl fggen 3 klnbz felirat kerl a szabvnyos outputra (kpernyre). A msodik rszben pe-
dig azt lthatjuk, ahogy az ltalunk megadott valamelyik alapmveleti jel (karakter) szerint elvgzi a
megfelel mveletet, majd az eredmnyt kirja a kpernyre. A break utastssal akadlyozzuk meg,
hogy a program tovbb menjen a kvetkez case gra. Ha pldul a msodik rszben nem lennnek ott
a break utastsok, a program egyms utn vgrehajtan mind a ngy gat, azaz, egyms utn kisz-
moln az eredmnyeket, s kpernyre rn azokat (ez is lehetne egy feladat!).

21
22
g) A ciklus utastsok
A programozsi nyelveken bizonyos utastsok automatikus ismtlst biztost programszerkezetet
itercinak vagy ciklusnak (loop) nevezzk. Ez az ismtls mindaddig tart, amg az ismtlsi felttel
igaznak bizonyul. A C++ nyelv hromfle ciklusutastst tartalmaz, melyek formja:
while (kifejezs) {utasts}
for (kifejezs) {utasts}
do {utasts} while (kifejezs)
A ciklusokat csoportosthatjuk a vezrlfelttel kirtkelsnek helye alapjn. Azokat a ciklusokat,
amelyeknl az utasts vgrehajtsa eltt kerl feldolgozsra a vezrlfelttel, ell tesztel ciklusnak
nevezzk. Ezeknl a ciklus soron kvetkez itercija csak akkor hajtdik vgre, ha a felttel igaz
(nem nulla). A while s a for ell tesztel ciklusok.
Ezzel szemben a do ciklus legalbb egyszer mindig lefut, hisz a vezrlfelttel ellenrzse az utasts
vgrehajtsa utn trtnik, azaz htul tesztel ciklus.
Mindhrom ciklusfajta esetn a helyesen szervezett ciklus befejezi a mkdst, amikor a vezrlfelt-
tel hamiss (nulla) vlik. Vannak esetek azonban, amikor szndkosan vagy vletlenl olyan ciklust
hozunk ltre, melynek vezrlfelttele soha sem lesz hamis. Ezeket a ciklusokat vgtelen ciklusnak
nevezzk.
A ciklusokbl a vezrlfelttel hamis rtknek bekvetkezte eltt is ki lehet ugrani (a vgtelen ciklusbl
is). Erre a clra tovbbi utastsokat biztost a C++ nyelv, mint a break, a return, illetve a ciklus trzsn
kvlre irnyul goto. A ciklus trzsnek bizonyos utastsait tugorhatjuk a continue utasts felhasznl-
sval. A continue hatsra a ciklus kvetkez itercijval folytatdik a program futsa.
A while ciklus a while ciklus mindaddig ismtli a hozz tartoz utastst (a ciklus trzst), amg a
vizsglt kifejezs (vezrlfelttel) rtke igaz (nem nulla). A vizsglat mindig megelzi az utasts
vgrehajtst. A while jl olvashat alakja:
while (kifejezs)
utasts
Nzznk egy egyszer pldt:

23
A for ciklus a for utastst ltalban akkor hasznljuk, ha a ciklusmagban megadott utastst adott
szmszor kvnjuk vgrehajtani. A for utasts ltalnos alakjban kln megjelltk az egyes kifeje-
zsek szerept:
for (init_kif ; felttel_kif ; lptet_kif)
Tekintsk pldaknt az elz feladatot, de most for ciklussal.

A do-while ciklus mint ahogy a ciklusok bevezet rszben emltettk, a do-while utastsban a cik-
lus trzst kpez utasts vgrehajtsa utn kerl sor a tesztelsre. gy a ciklus trzse legalbb egyszer
mindig vgrehajtdik. A do-while utasts hasznlatnak jl olvashat formja:
do
utasts
while (kifejezs);
A do-while ciklus futsa sorn mindig az utasts vgrehajtst kveti a kifejezs kirtkelse. Ameny-
nyiben a kifejezs rtke igaz (nem 0, true), akkor j iterci kezddik, mg hamis (0, false) rtk ese-
tn a ciklus befejezi mkdst.
Pldaknt tekintsk ismt az elzekben hasznlt sszead programot, most do-while ciklussal:

24
h) A break, continue s a return utastsok
Vannak esetek, amikor egy ciklus szoksos mkdsbe kzvetlenl be kell avatkoznunk. Ilyen feladat
pldul, amikor adott felttel teljeslse esetn ki kell ugrani a ciklusbl, vagy amikor a ciklus vgre-
hajtst a kvetkez itercival kvnjuk folytatni. Ezen feladatok elvgzsre a legtbb programozsi
nyelv a goto utasts hasznlatra hagyatkozik, azonban a C++ nyelven kln utastsok, a break s a
continue llnak a programoz rendelkezsre.
A break utasts a break hatsra az utastst tartalmaz legkzelebbi switch, while, for s do-while
utastsok mkdse megszakad s a vezrls a megszaktott mvelet utni els utastsra kerl.
Az elzekben mr lttuk a switch utasts plda programjban.
A continue utasts a continue utasts a while, a for s a do-while ciklusok soron kvetkez iter-
cijt indtja el, a ciklustrzsben a continue utn elhelyezked utastsok tlpsvel. A while s a do-
while utastsok esetn a kvetkez iterci a vezrlfelttel ismtelt kirtkelsvel kezddik. A for
ciklus esetben azonban, a felttel kifejezs kirtkelst megelzi a lptet kifejezs feldolgozsa.
Nzznk erre is egy egyszer pldt:

25
 Ez a kis program rszlet elsre nem biztos, hogy teljesen rthet. Nzzk meg a mkdst, valamint
vizsgljuk meg nhny rtkre.
A for ciklusban csak annyi szerepel, hogy az i rtkei 0-tl 99-ig mennek (i < 100).
Az if rtke kt rtk logikai s-bl ll ssze. gy csak akkor lesz az if rtke igaz, ha mind a kett
rsz rtke igaz. (logikai s: csak akkor igaz, ha mind a kett igaz). A kt rsz bal oldala: i % 7, jobb
oldala pedig: i % 11. ket a logikai s kti ssze, ami C++-ban a dupla &, azaz: &&.
A kifejezsben szerepl % (szzalk jel) a maradkos oszts maradkt jelenti. Ezt modulo-nak neve-
zik. Egy plda: 13 % 5 eredmnye: 3, hiszen 13-ban az 5 meg van 2-szer, s maradk a 3.
Az if minden egyes i-re kirtkeli, hogy igaz, vagy hamis. Nzzk meg 4 esetben: i=6, i=7, i=11, i=13.
Ha az i rtke 6, akkor mi trtnik? Az if bal oldala: i % 7, azaz 6 % 7, melynek eredmnye: 6, mivel
6-ban a 7 meg van 0-szor, s maradk a 6. Ez egy nulltl klnbz szm, gy rtke igaz. A logikai
s csak akkor igaz, ha mind a kett igaz, ezrt a msodikat is ki kell rtkelnie. Ez az i % 11, azaz 6
% 11, melynek eredmnye: 6, azaz igaz. gy a teljes if igaz lesz. Ennek kvetkezmnye az, hogy bele-
ugrik az if igaz gba, azaz a continue utastst vgrehajtja. Ennek kvetkezmnye pedig az, hogy i=6
esetn nem hajtja vgre a cout << i << endl; utastst, azaz a 6-ot nem rja ki.
Kvetkez eset legyen az, amikor az i rtke 7 (azaz a soron kvetkez). Nzzk a kifejezs bal olda-
lt: i % 7, azaz 7 % 7, melynek eredmnye a 0, mivel 7-ben a 7 meg van egyszer, s maradk a nulla.
gy az if-ben szerepl kifejezs bal oldala hamis (mivel rtke 0). A logikai s rtke csak akkor
igaz, ha mindkett igaz, de mivel az els hamis, ez mr nem is teljeslhet, gy a msodik rszt mr
meg sem nzi. gy a teljes if rtke hamis, ennek eredmnye az, hogy tugorja az if igaz gt, a
continue utastst. Mivel azt a sort tugrotta, ezrt a cout << i << endl; utasts viszont most
vgrehajtdik, teht kirja a kpernyre a 7-es szmot.
Nzzk, hogy az i=11 esetben mi trtnik. 11 % 7 eredmnye 4, teht igaz. gy megnzi a msodik fe-
lt is, ami 11 % 11, aminek eredmnye 0, teht hamis. Logikai s esetben az igaz s hamis ha-
misknt rtkeldik ki, gy a teljes if is hamisknt rtkeldik ki. Ennek kvetkezmnye az, hogy a
continue-t tugorja, majd kirja a 11-et a kpernyre.
i=13 esetben tulajdonkppen ugyanaz trtnik, mint az i=6 esetben (gondold vgig).
gy a program ugyanilyen mdon tallja meg a 7 vagy a 11 tbbszrseit.
A return utasts a return utasts befejezi az ppen fut fggvny mkdst s a vezrls vissza-
kerl a hv fggvnyhez. Ha a main() fggvnyben hasznljuk a return utastst, akkor a programunk
befejezi a futst, hisz a main() fggvny az (t hv) opercis rendszernek adja vissza a vezrlst.
A return utastst
return ;
alakban hasznlva olyan fggvnybl lphetnk ki, amely a nevvel nem ad vissza semmilyen rtket
(void tpus fggvny, illetve eljrs). A fggvnyek tbbsge azonban valamilyen rtkkel (a fgg-
vnyrtkkel) tr vissza a hvs helyre, mely rtket a return utastsban definilhatunk:
return kifejezs ;
A return utastssal rszletesen a fggvnyeket trgyal rszben foglalkozunk.
i) Defincik bevitele az utastsokba
A C++ nyelv megengedi, hogy a vltozk deklarcijt brhova helyezzk a program kdjn bell.
Egyetlen felttel, hogy a vltozt mindenkppen deklarlnunk (definilnunk) kell a felhasznlsa eltt.
lve ezzel a lehetsggel a vltoz deklarcija (defincija) s a felhasznlsa kzel helyezhet, elke-
rlve ezzel bizonyos gyakori programozsi hibkat.
Az utastsokban definilt vltozk csak az utastson bell hasznlhatk. gy ha a ciklusvltoz rt-
kre cikluson kvl is szksgnk van, nem szabad ezt a megoldst hasznlnunk.
26
8. Szrmaztatott adattpusok
Az eddigi pldkban olyan vltozkat hasznltunk, amelyek csak egyetlen rtk (skalr) trolsra al-
kalmasak. A programozs sorn azonban gyakran van arra szksg, hogy azonos vagy klnbz tpu-
s elemekbl ll adathalmazt a memriban troljunk, s az adatokon valamilyen mveletet hajtsunk
vgre. C++ nyelven a tmbk, illetve a felhasznli tpusok (struct, class, union) segtsgvel ele-
gnsan megoldhatjuk a fenti problmt.
a) Egydimenzis tmbk
A tmb (array) tpus olyan adatok halmaza, amelyek azonos tpusak, a memriban folytonosan he-
lyezkednek el s elre meghatrozott szm eleme van. Az elemek elrse a tmb nevt kvet
idexels opertorban megadott elemsorszm (index) segtsgvel trtnik. A tmb teht a vltozk
olyan kszlete, melyekre kzs nvvel s egy indexszel hivatkozunk.
A leggyakrabban hasznlt tmbtpus egyetlen kiterjedssel (dimenzival) rendelkezik. Az egydimenzi-
s tmbket vektornak is szoks nevezni. Azonban n. tbbdimenzis tmbk hasznlatra is adott a
lehetsg. Ktdimenzis tmbk esetn az elemek trolsa soronknt (sorfolytonosan) trtnik.
Az egydimenzis tmbket definilnunk kell, melynek ltalnos alakja:
tpus tmbnv [mret];
A definciban szerepl tpus, amely az elemek tpust definilja, a void s a fggvnytpus kivtelvel tet-
szleges tpus lehet. A szgletes zrjelek kztt a tmb mrett adjuk meg. Ez a mret, amelynek a fordt
ltal kiszmthat konstans kifejezsnek kell lennie, a tmbben trolhat elemek szmt definilja.
Pl. int a[5]
A fenti tmb egsz tpus, s 5 darab elem (egsz szmok) trolsra alkalmas.
A tmb elemeinek egyms utn trtn elrsre ltalban a for ciklust hasznljuk, melynek vltozja
a tmb indexe:
Pl. for (int i = 0 ; i < 5 ; i++)
a[i] = i * i;
A fenti pldban feltltttk a tmb elemeit az indexek ngyzetvel.
A tmb szmra a memriban lefoglalt memriaterlet mrete a sizeof(a) kifejezssel pontosan le-
krdezhet, mg a sizeof(a[0]) kifejezs egyetlen elem mrett adja meg. gy a kt kifejezs hnyado-
sbl (egszoszts) mindig megtudhat a tmb elemeinek szma.

27
Nzzk ezt a gyakorlatban:

Tekintsnk egy msik pldt tmb feltltsre s az elemeinek kiratsra. A tmb maximum 500 da-
rab egsz szmbl llhat.

28
Az elbbi feladat termszetesen karakterekkel is mkdik, me:

A C++ nyelv lehetv teszi, hogy a tmbket a definilsuk sorn inicializljuk. Ez a kezdrtk ads
eltr az egyszer vltozk esetn hasznlt megoldstl.
tpus tmbnv[mret] = {vesszvel tagolt inicilizcis lista};
Pl. int a[8] = {1, 2, 3, 4, 5, 6, 7, 8};
char b[7] = {a, b, c, d, e, f, g};
Tekintsnk erre is egy pldt, kt tmbt inicializltunk, majd kirattuk az elemeiket. Az els tmb
elemei egsz szmok, a msodik tmb elemei pedig karakterek, mindkt esetben a tmb mrett
nyolcelemre lltottuk be.

29
Gyakran szksg van arra, hogy egy tmb elemeit sorrendbe tegyk. Ilyenkor jl jn a sort fgg-
vny, nzzk ennek hasznlatt:

30
 Vegyk szre, hogy a sort fggvny hasznlathoz be kell hoznunk az algorithm knyvtrat
(#include <algorithm>). A fggvnynek kt paramtert kell megadni, hnyadik elemtl h-
nyadik elemig rendezze a tmbt. Alapesetben minden elemet rendezni szeretnnk, ekkor els param-
terknt a tmbnk nevt adjuk meg, msodik paramterknt pedig a tmb nevt, majd egy pluszjelet
kveten a tmbnk hosszt (ahogyan az ltszik is az elbbi pldban). Azonban megadhatunk ennl
kevesebbet is, mondjuk, az els hrom elemet rendezze. Ilyenkor msodik paramterknt a kvetkezt
kell megadnunk: tmb neve + 3. Azt is megtehetjk, hogy ne az els elemtl kezdden rendezze az
elemeket, hanem pldul csak az tdiktl. Ehhez az els paramter esetn a tmb neve utn, szintn
egy pluszjelet kveten megadjuk az tt: tmb neve + 5. A kettt kombinlni is lehet, tegyk fel,
hogy a harmadik elemtl akarunk rendezni a nyolcadik elemig:
sort(tmb neve + 3, tmb neve + 8).
Vigyzzunk arra, hogy a msodik paramternl lv szm nagyobb legyen az els paramternl lv
szmnl!
b) Vektor
A vector tpussal egydimenzis tmbket helyettesthetnk. A lnyege, hogy sok azonos tpus
elemet egyestnk a vektor fogalmban egy adategysgg. A vektor a memriban sorfolytonosan he-
lyezkedik el. Vektorok hasznlathoz be kell hozni a vector osztlyt:
#include <vector>
Ezutn ltrehozhatunk vektorokat a kvetkezkppen:
vector <tpus> nv;
Az elbbi deklarcival egy res vektor jtt ltre megadott nvvel. Megadhatjuk deklarlskor, hogy
hny elem legyen a vektorunk. Ilyenkor az elemeknek nulla rtket ad.
vector <tpus> nv(elemszm);
Nzznk erre egy egyszer pldt:

Azt is megtehetjk, hogy a vektor ltrehozsakor az elemszmon kvl megadjuk az elemeket is. Eb-
ben az esetben a vektor tartalma annyi darab megadott rtk lesz, amennyi az elemszm. A kvetkez
pldban 7 darab 8-as, illetve 12 darab G karakter lesz a vektorok tartalma.

31
Ha egy vektort fel szeretnnk gyorsan tlteni vletlen szmokkal, akkor hasznljuk a rand() fgg-
vnyt. Ha a generlt szmok tartomnyt is meg akarjuk hatrozni, akkor a rand() fggvnynket a
kvetkezkppen hasznljuk (1 s 100 kz es egsz szmot generl):

32
Ha vektorokkal dolgozunk, hasznlhatjuk a tagfggvnyeit (tmbknl nincsenek ilyenek). A tagfgg-
vnyek hasznlatval knnyebben s gyorsabban tudunk dolgozni, ezrt igen hasznosak. A tagfggv-
nyek gy hvhatk el, hogy a vektor neve utn egy pontot runk, majd a felbukkan listbl kivlaszt-
juk a szmunkra megfelel fggvnyt. Tekintsnk most nhnyat a teljessg ignye nlkl. Bvebb in-
formcit s tovbbi tagfggvnyeket a kvetkez cmen tallhatunk:
http://www.cplusplus.com/reference/vector/vector/?kw=vector
res-e a vektor (0 HAMIS, 1 IGAZ)
vektor_neve.empty();
Plda:

Vektor elemeinek szma

vektor_neve.size();
Plda:

33
Hozzfrs a vektor i. elemhez
vektor_neve.at(i);
Plda:

A vektor vghez hozzfz egy megadott elemet

vektor_neve.push_back(elem);
Plda:

34
Elhagyja a vektor utols elemt
vektor_neve.pop_back();
Plda:

Megadja a vektor els elemt

vektor_neve.front();
Plda:

35
Megadja a vektor utols elemt
vektor_neve.back();
Plda:

Trli a vektor minden elemt

vektor_neve.clear();
Plda:

36
Termszetesen a vektorok elemeit is sorba rendezhetjk, amint azt mr a tmbknl lttuk. A szintak-
tika itt egy kicsit ms. Az algorithm knyvtrat most is be kell hvni, majd hasznlhatjuk a
sort() fggvnyt. Alapesetben kt paramtere van. Az els paramter megadja, hogy melyik elem-
tl, a msodik paramter pedig, hogy melyik elemig hajtsa vgre a sorba rendezst. Az albbi plda 20.
sorban lthat, hogy az sszes elemet rendezni szeretnnk (begin kezdet, end vg).
Plda:

Most is lehetsgnk van arra, hogy megvltoztassuk a rendezni kvnt elemek tartomnyt. Az els
paramternl egy pluszjel utn berhatunk egy szmot, ez jelzi, hogy ettl a helytl rendezi az eleme-
ket (vigyzat, 0-tl szmolunk). A msodik paramternl egy mnuszjel utn tehetjk ugyanezt, vissza-
fel haladva ezen a helyen lv elemig rendez (itt is 0-tl szmolunk). A kvetkez pldban azt lt-
hatjuk, hogy a 10 elem vektorunk 3. helyn ll szm az els rendezend elem, s visszafel szmol-
va a 4. helyen ll szm az utols rendezend elem. Mindkt esetben figyelembe vettem a nulltl val
szmolst: + 2 pldul azt jelenti valjban, hogy 0. 1. 2. azaz, a harmadik helyrl van sz.

37
 Plda:

c) Tbbdimenzis tmb
C++-ban tulajdonkppen olyan, hogy tbbdimenzis tmb nem ltezik. Helyette a nyelv a tmbkben
lv tmbket tmogatja. Ez alatt mit is rtnk?
Az egydimenzis tmbkkel az elbb foglalkoztunk. Egy egyszer, 10 egsz szmot tartalmaz tm-
bt nagyon knnyen fel tudunk venni:
int tomb[10];
Megjegyzend, hogy ennek mrete fix, azaz soha nem vltozhat, valamint fordtsi idben foglaldik
le a memriaterlet.
Nzznk egy olyan pldt, ahol szksgnk lenne egy tbbdimenzis tmbre, pldul, ha mtrixokkal
szeretnnk szmolni. Egy mtrix igazbl nem ms, mint tblzatba rendezett szmok. Lehet ket
sszeadni s szorozni is. Ennek mdja s a mgtte lv matematika most nem fontos. A lnyeg, hogy
ezeket valahogyan el szeretnnk trolni, hogy aztn tudjunk velk dolgozni.
Br nem ltezik tbbdimenzis tmb, a C++ mgis megengedi, hogy egyszeren, az egydimenzis
tmbkhz hasonlan is tudjuk kezelni ket. Ha pldul egy 10 x 10-es mret egsz szmokat tartal-
maz ktdimenzis tmbt szeretnnk, azt felvehetjk a kvetkez, egyszer mdon:
int tomb[10] [10];
A tmb elemeihez ugyangy hozzfrhetnk, mint ahogyan azt az egydimenzis tmbk esetben tet-
tk, azaz pldul ha az tdik sor 4-edik elemhez szeretnnk hozzfrni, s rtkl a 3-as szmot sze-
retnnk adni, az a kvetkez kppen nz ki:

38
 tomb[4][5] = 3;
Igazbl, hogy melyiket vesszk sornak s melyiket oszlopnak teljesen rajtunk mlik. Azonban a bal-
rl jobbra trtn rs / olvass a megszokott nlunk, valamint a kvetkez sor alatt mi az alatta lv
sort rtjk. gy a
tomb[4][5]
esetben a 4 a sorban negyedik lv elemre utal, teht ez az oszlopszm. Az 5 pedig azt jelenti,
hogy az tdik sorban, vagyis ez a sorszmot jelenti.
Vajban a tbbdimenzis tmbket nem gy szoktuk hasznlni, hanem dinamikus memriakezelssel,
amire egyelre bvebben nem trnk ki.
Tbb dimenzis tmb termszetesen nem csak 2 dimenzis lehet, hanem akrmekkora.
A kvetkez pldban kt darab 5*5-s tmbt deklarltunk, melyek elemei egsz szmok. A tmb-
ket inicializltuk, azaz rtkeket adtunk az elemeknek, hogy ne kelljen neknk berni. Ezutn kirattuk
a tmbket, majd egyszer szorzssal kiszmoltattuk a kt tmb megfelel elemeinek szorzatait, majd
ezt a szorzat tmbt is kpernyre rattuk.

39
d) Sztringek
Az egydimenzis tmbket leggyakrabban karakter sztringek trolsra hasznljuk. A C++ nyelv nem
rendelkezik nll sztring tpussal, ezrt a karaktertmbket hasznlja a sztringek trolsra. A sztring
teht olyan karaktertmb (char[]), melyben a karaktersorozat vgt nulla rtk bjt (0) jelzi.
Amikor helyet foglalunk valamely sztring szmra, akkor a sztring vgt jelz bjtot is figyelembe kell
venni. Ha az str tmbben maximlisan 80 karakteres szveget szeretnnk trolni, akkor a tmb mrett
80+1=81-nek kell megadnunk.
char sor[81];
Fontos, hogy mindig lezrjuk binris nullval, amit karakterknt gy runk: \0. Ezt azrt tesszk,
mert megllapods, hogy ezzel jelezzk egy karakterlnc, azaz egy sztring vgt, s minden sztring
kezel fggvnyt is gy runk meg, hogy ezt a lezr jelet figyeljk. Termszetesen a Standard
knyvtrban (std) lv sztring kezel metdusok (eljrsok, fggvnyek) is ezt figyelik, gy ha elt-
rnk ettl, vagy csak elfelejtjk, akkor mris mindenfle nehezen kiderthet hibhoz juthatunk.
Egy ilyen sztring, ami egy C tpus sztring (hiszen a C nyelvbl ered, mint ahogy szinte minden a
C++-ban) nem ms, mint a memriban egyms mellett lv karakterek sorozata. Az egyms mellett
lvsg persze nem mindig igaz, csak abban az esetben lehetsges, ha fordtsi idben foglaldik le a
memria terlete. Eddig csak olyan pldkat lttunk, ahol ez gy trtnt. Ilyenkor persze, ha tl nagy
helyet szeretnnk krni, azt az opercis rendszer nem biztos, hogy teljesteni tudja. Kzel sem biztos,
hogy tall akkor sszefgg szabad helyet a memriban, mint amekkorra mi rni szeretnnk.
Amennyiben a sztringnket elfelejtjk lezrni egy nullval (\0), akkor, ha ki szeretnnk rni az ott
lv tartalmat, mondjuk azt, hogy alma, akkor egszen addig olvassa azt a memriaterletet, amg
egy nullt (\0) nem tall. gy knnyen lehet, hogy a vrt eredmny az alma, azonban amit a kp-
ernyn ltunk, az inkbb hasonlt erre: alma+&@[tz~^. Az gy kirt memria szemt tartalmazhat
nem megjelentend karaktereket. Egybknt azrt jelennek meg ms karakterek, mert azon a mem-
riaterleten mr van valami. Ezekre, ha alacsony szinten tekintnk nem msok, mint szmok. De mivel
sztring kiratst krtnk, ezrt a program karakterekknt szeretn megjelenteni, azaz minden ott lv 1
bjtnyi hosszsg szmnak megkeresi az ASCII-beli karakter megfeleljt, s azt rja ki. Nem megje-
lenthet karakterek pldul a tabultor, a sortrs, stb.
Ha egy sztringbe rni szeretnnk, a helyzet mg rosszabb, de legalbb knnyebben szrevehet. Ebben
az esetben egy olyan helyre szeretnnk rni, amit nem foglaltunk le a programunk szmra. Abban a
pillanatban, hogy ilyet szeretnnk tenni, az opercis rendszer rcsap egy nagyot a keznkre, amitl
elszll a program. Ha debug mdban indtottuk az ppen hasznlt IDE-nkbl (Integrated
Developement Enviorement ~ Integrlt fejleszti krnyezet), akkor valsznleg nem csak elszll a
program, de mindenfle hasznos hibazenetet is kir a szmunkra.
gy teht mindig, minden esetben figyeljnk a sztringek lezrsra, s ne prbljunk meg eltrni a
szabvnytl.
40
 Az elmondottakra tekintsnk egy pldt:

A 14. sorban lezrtuk az utols elemet egy binris nullval, az elzekben elmondott okok miatt. Az is
szpen ltszik (ha lefuttatjuk a programot), hogy a kpernyre 4 darab a bet rdik, hiszen a valdi
tmbmret ennyi.
e) A String osztly
Az alacsony szint, C tpus sztringek kezelse igencsak nehzkes. Ezrt ltezik egy, a Standard
Library-ban ltez String osztly, amely nagyban megknnytheti a dolgunkat.
Rsze egy, az elbb rt C tpus sztring. Ha nagyon mlyre megynk, ez megtallhat benne. Azonban
a felelssg nagy rszt leveszi a vllunkrl. A sajt memrijt dinamikusan kezeli. Krhetnk ellen-
rztt hozzfrst is, gy nem az opercis rendszer csap r a keznkre, s nem szll el a program,
hanem egy kivtel dobdik. A kivtel egy olyan hiba, amire elre fel tudunk kszlni. A kivtelkezels
egy elg komoly s nehz tma, ezrt errl itt bvebben nem rok.
A String osztly rengeteg tagmetdussal rendelkezik, melyek hasznlatval egy mondatban egy sz
megkeresse, bizonyos rszek kicserlse, vagy az alma fellrsa kkuszdi-ra (ami lnyegeseb-
ben hosszabb sz) mr pofon egyszer feladat.
A string tpus (osztly) hasznlathoz a string include file-t kell betlteni.
#include <string>
Ha egy string adattal akarunk valamilyen mveletet vgezni akkor a kvetkez formt kell hasznlni:
stringvltoz.mvelet (argumentumok)
A szvegben elfordul karakter szmozsa nullval kezddik s a hossz 1-ig tart. Az utols ka-
rakternek nem kell zrusnak lennie, mint a C nyelvben, az osztly tudja magrl hogy milyen hossz.
Az rtkads szvegeknl is mkdik, br az rtkadsnl a jobb oldali szveg tmsoldik a bal olda-
li szvegbe!
string szoveg1 = "alma"
string szoveg2 = "paradicsom"
szoveg1 = szoveg2
A szoveg1 tartalma "paradicsom" lesz.

41
A string osztly nhny egyszeren hasznlhat tagfggvnye:
Szveg (string) hossza:
szveg.lenght();
Plda:

Hozzfrs a szveg i. karakterhez

szveg.at(i);
Plda:

res-e a szveg (0 HAMIS, 1 IGAZ)

szveg.empty();
Plda:

42
Szveg kirtse
szveg.clear();
Plda:

Szvegrsz trlse
szveg.erase();
Kt paramtere van, hnyadik pozcitl trljnk, s mennyi karaktert. Az albbi pldban kt karak-
ter marad: Aa.
Plda:

43
Szvegrsz kivgsa
szveg.substr();
Kt paramtere van, hnyadik pozcitl, s hny karakter vgjunk ki. Az albbi pldban kt karaktert
vgunk ki az 1. pozcitl kezdve, vagyis az eredmny: lm.
Plda:

Szveg hozzfzs szveghez

szveg.append();
Az albbi plda eredmnye: Almaecet.
Plda:

44
Szveg beillesztse szvegbe
szveg.insert();
Kt paramter van, az elsben megadjuk, hogy hnyadik pozcitl, a msodikban pedig a beilleszten-
d szveg tallhat. Az albbi plda eredmnye: Alma.
Plda:

Szvegrsz lecserlse
szveg.replace();
Hrom paramter van, hnyadik pozcitl, hny karaktert s mire cserljen le. Az albbi plda ered-
mnye: Barna folyas.
Plda:

Szvegrsz keresse
szveg.find();
Kt paramtere van, mit keresnk (szveg) s hnyadik pozcitl keressnk (ha nem adjuk meg, ak-
kor ellrl keres). Ha tbb egyforma szvegrsz van, akkor is csak az els megtallt szvegrsz poz-
cijt adja meg (a szvegrsz els karakternek pozcijt). Ha nem tallja meg a szvegrszt, akkor
egy gynevezett extremlis rtket (szlsrtket) ad vissza. Ez tulajdonkppen egy nem ltez
index, ennek rtke a gp hardvertl fgg, pl. 32 bites gp esetn 232 = 4 294 967 295.
Ezt a nem ltez index rtket megnzhetjk az npos tagllandval: cout << szoveg.npos;
Az albbi pldban az ugrani szvegrszt keressk ellrl kezdve, els elfordulsnak els karaktere
a 12. pozcin helyezkedik el.

45
Plda:

A kvetkez pldban megadtuk azt is, hogy hnyadik pozcitl kezdjen keresni. Mivel 13-at adtunk
meg, gy onnan vgzi a keresst, s a 39. pozcin meg is tallja a kvetkez ugrani szvegrsz els
karaktert.
Plda:

Szvegrsz keresse
szveg.rfind();
Majdnem ugyanaz, mint az elz keress tagfggvny. Lnyeges klnbsg azonban, hogy az utols
elfordulst keresi!

46
A fenti pldban a msodik elforduls els karakternek pozcijt kapjuk meg, azaz, a 39. pozcit.
Ha megadunk egy pozcit, akkor onnan keres, de visszafel nzi a szveget! Teht, ha pldul a 38.
pozcitl akarunk keresni, akkor az eredmny 12 lesz. Ez azrt van, mert arrl a helyrl visszafel
csak egyszer fordul el az ugrani sz, s ennek els karaktere a 12. pozcin van a szvegben. Nz-
zk ezt is meg egy pldval:

Ha a 11. pozcitl vagy annl kisebb pozcitl keresnk, akkor nem tallja meg az ugrani szveg-
rszt. Ekkor azt a bizonyos extremlis rtket kapjuk vissza. Lssuk:

Szvegek sszehasonltsa
szveg.compare();
Egy paramtere van, az a szvegrsz, melyet sszehasonltunk az eredeti szvegnkkel. Ha teljesen
megegyezik (kis-nagy bet eltrseket is figyel), akkor 0 (IGAZ), egybknt ms szm (HAMIS).

47
f) A struktra tpus
A programozs sorn azonban gyakran tallkozhatunk olyan problmkkal, amelyek megoldshoz
klnbz tpus adatokat nll programozsi egysgben kell feldolgoznunk. Tipikus terlete az
ilyen jelleg feladatoknak az adatbzis-kezels, ahol a fjl trolsi egysge a rekord tetszleges me-
zkbl plhet fel.
C++ nyelven a struktra (struct) tpus tbb tetszleges tpus (kivve a void s a fggvny tpust) ada-
tok egyttese. Ezek az adatelemek nll, a struktrn bell rvnyes nevekkel rendelkeznek. Az ob-
jektumok szoksos elnevezse struktraelem vagy adattag (member).
A struktra tpus vltoz ltrehozsa logikailag kt rszre oszthat. Elszr deklarlnunk kell magt a
struktratpust, melyet felhasznlva vltozkat definilhatunk. A struktra szerkezett meghatroz
deklarci ltalnos formja:
struct struktratpus
{
tpus1 tag1;
tpus2 tag2;

tpusN tagN;
};
Felhvjuk a figyelmet arra, hogy a struktra deklarcija azon kevs esetek egyike, ahol a pontosvesz-
szt ktelez kitenni. Az adattagok deklarcijra a C++ nyelv szoksos deklarcis szablyai rv-
nyesek. A fenti tpussal vltozt a mr megismert mdon kszthetnk.
A struktra (struct) s a tmbk kztt a legnagyobb klnbsg, hogy mg egy tmbben csak egy fle
adattpust trolhatunk, a struktra tbb tpus adat trolsra is alkalmas.
Erre egy egyszer plda lehet, ha emberek adatait szeretnnk trolni (nevket, lakcmket, szletsi
dtumukat illetve egy azonostt). Tbbfle adatrl beszlnk, ezrt kln tmbk kellennek a nevek
(szvegek), az azonostk (egsz szmok), stb. trolsra. Az adatokat gy nehzkes kezelni, nehz ve-
lk dolgozni. Azonban, ha struktrt hasznlunk, akkor egy struktrban ssze tudjuk foglalni mind-
ezt, s jval egyszerbben tudjuk az adatainkat kezelni. Megj.: A feladat megoldsnl hasznljunk
egy struktrt a dtumhoz is.

48
 Nzznk egy egyszer pldt:

A tagokat a .(pont)-tal tudjuk elrni. Fontos megemlteni, hogy C++-ban a struktra az tulajdonkppen
egy osztly (class), melynek minden egyes adattagja publikus (public). Hogy ez mit jelent, arrl most
mg ne beszljnk. A struktrkat gyakorlatilag minden emelt szint informatika rettsgi programo-
zs rsznl rdemes hasznlni.
9. Fggvnyek
A fggvny a C++ program olyan nvvel elltott egysge (alprogram), amely a program ms rszeibl
annyiszor meghvhat, ahnyszor csak szksg van a fggvnyben definilt tevkenysgsorozatra. A
hagyomnyos (funkci-orientlt) C++ program ltalban sok kismret, jl kzben tarthat fggvny-

49
bl pl fel. A gyakran hasznlt fggvnyek lefordtott kdjt knyvtrakba rendezhetjk, amelyekbl
a szerkesztprogram a hivatkozott fggvnyeket bepti a programunkba.
A fggvnyek hatkony felhasznlsa rdekben a C++ nyelv lehetsget biztost arra, hogy a fgg-
vny bizonyos bels trolinak a fggvnyhvs sorn adjunk rtket. Hogy melyek ezek a trolk s
milyentpussal rendelkeznek, azt a fggvny defincijban a fggvny neve utn zrjelben kell meg-
adnunk. A hvsnl pedig hasonl formban kell felsorolnunk az tadni kvnt rtkeket. A szakiroda-
lom ezekre a trolkra s rtkekre klnbz nevekkel hivatkozik.
A fggvny-definciban szerepl trolk A fggvnyhvs sorn megadott rtkek
formlis paramterek aktulis paramterek
formlis argumentumok aktulis argumentumok
paramterek argumentumok
A fggvnyhvs sorn a vezrls a hv fggvnytl tkerl az aktivizlt fggvnyhez. Az argumen-
tumok (amennyiben vannak) szintn taddnak a meghvott fggvnynek. A mr bemutatott return
utasts vgrehajtsakor, illetve a fggvny fizikai vgnek elrsekor a hvott fggvny visszatr a h-
vs helyre, s a return utastsban szerepl kifejezs, mint fggvnyrtk (visszatrsi rtk) jelenik
meg. A visszatrsi rtk nem ms, mint a fggvnyhvs kifejezs rtke.
A sajt kszts fggvnyeinket mindig definilni kell. A definci, amelyet csak egyszer lehet meg-
adni, a C++ programon bell brhol elhelyezkedhet. Amennyiben a fggvny defincija megelzi a
felhasznls (hvs) helyt akkor, ez egyben a fggvny prototpusa is.
A fggvny deklarcija (prototpusa) tartalmazza a fggvny nevt, visszatrsi rtknek tpust va-
lamint informcit szolgltat a paramterek szmrl s tpusrl. A prototpust a fggvnyhvs eltt
kell elhelyeznnk a programban. A C++ fordt csak a prototpus ismeretben fordtja le a fggvny-
hvst. (A fggvny defincija helyettesti a prototpust.)
Az elmondottakban megtalljuk annak magyarzatt, hogy a szabvnyos knyvtri fggvnyek dekla-
rcijt tartalmaz fejllomnyokat mirt a forrsfjl elejn ptjk be (#include) a programunkba. Va-
lamely prototpus tbbszr is szerepelhet, azonban mindegyik elfordulsnak azonosnak kell lennie.
Nzzk meg a fggvnydefinci ltalnos formjt! A fggvny fejsorban a paramter-deklarcis
lista az egyes paramtereket vessz elvlasztva tartalmazza. Minden egyes paramter eltt szerepel
annak tpusa.
<visszatrsi tpus> fggvnynv (<paramter-deklarcis lista>)
{
fggvny trzse
<loklis defincik s deklarcik>
<utastsok>
}

50
A <> jelek kztt megadott rszek hinyozhatnak a defincibl. Pldaknt ksztsk el kt egsz
szm sszeadst vgz fggvnyt:

A fenti plda 4. sorban lthat a fggvny prototpusa, a 22. sortl pedig maga a fggvny. A protot-
pusban megadtuk a fggvny visszatrsi rtknek tpust (int), illetve a paramterek szmt, tpust
(2 darab egsz tpus paramter). A 16. sorban hvtuk meg a fggvnyt az ltalunk megadott kt egsz
szmmal, s ugyanitt ki is rattuk az eredmnyt. Fontos megjegyezni, hogy a fggvny hvsakor az n
s az m paramterek rtkei tmsoldnak a 22. sortl kezdd fggvny paramtereibe (n paramter
az a paramterbe, m paramter pedig a b paramterbe).
Nzznk most egy kicsit sszetettebb pldt! A jl ismert msodfok egyenlet megold kplett fel-
hasznlva szmoljuk ki a gykket fggvny segtsgvel. Ehhez elszr be kell tlteni a cmath osz-
tlyt (#include <cmath>), mert hasznlni szeretnnk a ngyzetgyk fggvnyt (sqrt). Ebben az
osztlyban mg sok, msok ltal megrt matematikai fggvnyek s egyb defincik tallhatk. Az 5.
sorban ksztettk el a fggvnynk prototpust, melynek visszatrsi rtke void tpus (nem ad
vissza rtket, tulajdonkppen egy eljrs), s hrom paramtere pedig double tpus. A fggvnyt a
26. sortl kezdden alkottuk meg, s a 19. sorban hvtuk meg az ltalunk megadott hrom tizedes
trttel (termszetesen egsz szmok is megadhatk). A programunkat egy kicsit formztuk is a megfe-
lel escape karakterekkel (tabultor, sortrs).

51
52
Tglalap kerlett kiszmol program.

Csonka gla trfogatt kiszmol program.

53
10. Fjlkezels
Egy programban nem csak a kpernyre trtn rsra vagy az onnan val beolvassra lehet szks-
gnk. Sok esetben fjlokat is kell kezelnnk. Eddig az iostream et hasznltuk a C++ standard library-
bl. Segtsgvel tudtunk kirni s beolvasni a kpernyrl. A fjlmveletekhez az fstream et hasz-
nlhatjuk.
A cout-hoz hasonl adatfolyamot hasznlhatunk fjlkezelshez is. az fstream-et include-olva ltrehoz-
hatunk ofstream, ifstream s fstream objektumokat. Az ofstream az output file stream. Segtsgvel lt-
rehozhatunk fjlokat s rhatunk beljk. Az ifstream az input file stream. Segtsgvel fjlokbl tu-
dunk beolvasni adatokat. Az fstream tulajdonkppen a kett egytt (file stream). Vele tudunk fjlokat
ltrehozni, megnyitni, bele tudunk rni, olvasni tudunk beljk s le is tudjuk ket zrni. Fjlok meg-
nyitsra s lezrsra termszetesen a csak rni s a csak olvasni tud ofstream s ifstream is kpes.
Kvessnk vgig egy rvid pldt, amiben megnyitunk egy ltez a.txt fjlt, beolvassuk a tartalmt
soronknt, majd minden egyes sort kirunk egy b.txt fjlba. Hasznljunk a feladathoz kln egy
ifstream s egy ofstream objektumot.

A pldban, mint lthat, ltrehoztunk egy ifstream-et file_bemenet nven, s egy ofstream-et fi-
le_kimenet nven. Mind a kettnl az open() tagfggvnnyel nyitottuk meg a fjlokat. Az ofstream eset-
ben, mivel nem tallt ilyen fjlt, automatikusan ltrehozza azt resen, majd megnyitja.
Utna egy while ciklusban olvassuk be a fjl tartalmt soronknt. A while feltteleknt azt vizsgljuk,
hogy a megnyitott fjlunknl a vgn jrunk-e. Ezt az eof() tagfggvnnyel tesszk meg. EOF azaz End Of File.
Hogy ezt honnan tudja? Minden opercis rendszer hasznl valamilyen karaktert, amivel a fjl vgeit jelzi.
Egy sor beolvasshoz a getline() fggvnyt hasznljuk. A fggvny els paramtere egy input stream. Ez lehet
a mr korbban hasznlt cin is, amennyiben a kpernyrl szeretnnk beolvasni egy sort, vagy akr lehet egy
54
ifstream objektum is, mint a jelen esetben. A metdus msodik paramterknt egy stringet vr, ahova beolvas-
hatja a sort. Erre a clra ltrehoztunk egy stringet sor nven, amiben mindig ideiglenesen eltroljuk az adott
sort.
Miutn ebbe beolvastuk, a file_kimenet-nkbe beleirnytjuk a mr megszokott << opertorral a sor nev
stringnk tartalmt.
Miutn az egsz fjlt tmsoltuk, a vgn lezrjuk a file_bemenet s a file_kimenet ifstream illetve ofstream
objektumainkat.
Fontos megjegyezni, hogy a getline() fggvny mindent beolvas egszen a sortrsig (windows-ban ez a \n
karakter), de a sortrs nem kerl bele a stringbe. Ezrt is tettnk kln, minden egyes sorunk utn egy sortrst
a fjlba val rsnl.
Egy emelt szint informatika rettsgi sorn a legtbbszr nem arra van szksg, hogy egy fjlt soronknt ke-
zeljnk, hanem a forrsfjlban megadott rtkeket be tudjuk olvasni s el tudjuk trolni valami fle, ltalunk lt-
rehozott adatszerkezetben (ami az esetek 99%-ban egy struktra).
Nzznk egy olyan egyszer pldt, ahol egy hzillat adatait olvassuk be. A fjl legyen egy olvashat txt fjl,
melyben egy sor egy llat adatait tartalmazza rendre: az llat azonostja, neve, szletsi ve, slya (kg).
A fjl tartalmra plda:
3255532123 Bodri 2004 11.3
3255534417 Fles 1999 7.4

Egy rettsgi feladatnl mindig megmondjk, hogy maximum hny sor lehet a forrsban (hogy ne kelljen dina-
mikus memriakezelssel foglalkozni), tovbb az egyes adatok tpusra is tesznek valamilyen utalsokat, pl-
dul, hogy a szletsi vnl csak az vet rgztik, vagy pldul azt, hogy a slya nem biztos, hogy egy egsz
szm. A feladat legyen annyi, hogy az adatokat beolvassuk s eltroljuk, majd utna kirjuk ket a kpernyre.

55
A feladat megoldsa sorn ltrehoztunk egy, az adatoknak megfelel struktrt, s egy ilyen struktrkbl ll
tmbt, amiben eltrolhatjuk az adatokat. Tovbb ltrehoztunk mg egy egsz szmot, amiben azt troljuk el,
hogy hny llat adatait olvastuk be a fjlbl.
Minden ilyen adatot globlisan vettnk fel, mert gy sokkal egyszerbben tudjuk kezelni s elrjk ket min-
denhol. Ez persze nem egy szp megolds, de egy rettsgi feladatnl ez egyltaln nem szmt. Ha minden
szksges adatot gy, globlisknt vesznk fel, akkor azokat minden fggvnynkben elrnk, gy nem kell az
adatokat tadni paramterknt.
A pldban az elzhz kpest az a nagy klnbsg, hogy nem soronknt olvasunk be a fjlbl, hanem adaton-
knt. Ezt a cin-hez hasonlknt hasznlhatjuk a >> opertorral. gy knnyen be tudjuk olvasni az adatokat.
Ha gy tesznk, a kurzor pozcijtl minden white space-t tugrik (szkz, tabultor, sortrs, stb.) majd beol-
vas egy adatnak vlt adatot. Ez alatt azt rtjk, hogy pldul az llat slynak beolvassakor azt nem egy
egsz szmknt egy karakterknt s egy msik egsz szmknt szleli (11.4), hanem egy lebegpontos szm-
knt.
A mr az elbb ltott pldban is szerepl while ciklusban olvasunk be mindent, egszen a fjl vgig, majd azt
mindig eltroljuk a tmbnkben. A beolvass utn lezrjuk a tmbt, majd ismt bejrjuk s kirjuk a mr ltott
mdon.

56
Fggelk
Programozsi ttelek
1) Az sszegzs ttele
Adott egy N elem szmsorozat. Szmtsuk ki az elemek sszegt! A sorozat elemeit mr ismertnek
ttelezzk fel s ezeket az N elem A(N) vektorban troljuk.

57
2) Az eldnts ttele
Adott egy N elem sorozat, s egy, a sorozaton rtelmezett T tulajdonsg. Dntsk el, hogy van-e a so-
rozatban legalbb egy T tulajdonsg elem (30-nl nagyobb szm)!

58
3) A kivlaszts ttele
Adott egy N elem sorozat s egy, a sorozat elemein rtelmezett T tulajdonsg. Tudjuk, hogy a soro-
zatban van legalbb egy T tulajdonsg elem (30-nl nagyobb szm). Adjuk meg az els ilyen elem
sorszmt!

59
4) A megszmlls ttele
Adott egy N elem sorozat s egy, a sorozat elemein rtelmezett T tulajdonsg (30-nl nagyobb szm).
Szmoljuk meg, hogy hny T tulajdonsg eleme van a sorozatnak.

60
5) A lineris keress ttele
Adott egy N elem sorozat s egy, a sorozat elemein rtelmezett T tulajdonsg (30-nl nagyobb).
Dntsk el, hogy a sorozatban van-e T tulajdonsg elem, s ha igen, akkor adjuk meg az els ilyen
elem sorszmt!

61
6) A maximum s minimum rtk keress ttele
Adott egy N elem A(N) sorozat. Hatrozzuk meg a sorozat legnagyobb s legkisebb elemnek rt-
kt! Megjegyzs: Nem vizsgljuk azokat az eseteket, amikor tbb maximlis vagy minimlis rtk
van, esetleg a sorozat minden eleme egyforma.

62
7) A kivlogats ttele
Adott egy N elem sorozat A(N) s egy, a sorozat elemein rtelmezett T tulajdonsg (30-nl nagyobb).
Hatrozzuk meg a sorozat sszes T tulajdonsg elemt, s gyjtsk ki ezen elemek sorszmait a B()
vektorba! (A mvelet utn rjuk ki az eredmnyt!)

63
8) A kzvetlen kivlasztsos rendezs ttele
Adott egy N elem A(N) sorozat. Rendezzk nvekv sorrendbe a sorozat tagjait! Megjegyzs: Ez a
legegyszerbb, de leglassbb rendezsi forma. A lnyege az, hogy kt ciklussal dolgozva elszr A(1)-
tl indulva kivlasztjuk a vektor legkisebb elemt gy, hogy az elemeket sszehasonltjuk s felcserl-
jk, ha rossz sorrendben vannak. Az els helyen ezutn biztos a legkisebb elem fog llni! Ezutn A(2)-
tl kezdve megismteljk az eljrst, egszen A(N-1)-ig.

64