Katona József Király Zoltán. Objektumorientált szoftverfejlesztés C++ nyelven

Katona József−Király Z oltán

Objektumorientált szoftverfejlesztés C++ nyelven (KONSTRUKTOR TÍPUSOK, DESTRUKTOR, OSZTÁLYSABLONOK, FÜGGVÉNYSABLONOK ÉS FÜGGVÉNYTÚLTERHELÉSEK)

© Katona József−Király Zoltán, 2015

Lektorálta: Dr. Kusper Gábor, tanszékvezető főiskolai docens

D U F PRESS d u n a ú j vá r o s i f ő i s k o l a w w w. d u f . h u

Kiadóvezető: Németh István Felelős szerkesztő: Nemeskéry Artúr Layout és tördelés: Duma Attila

Kiadja: DUF Press, a Dunaújvárosi Főiskola kiadója Felelős kiadó: Dr. András István Készült a HTSART nyomdában. Felelős vezető: Halász Iván ISBN 978-963-9915-53-4 ISSN 2415-9115

Dunaújváros, 2015

Tartalom

Tartalom Nagy Bálint 1. Fejezet Trajektóriák ábrázolása A konstruktor típusok



59 Alapértelmezett konstruktor (default constructor) 10 Katona József–Kővári Attila–Ujbányi Tibor Másoló konstruktor (copy constructor) 10 Agy-számítógépek interfészek rendszerbe történő illesztése 29 Mintapélda 11 Katona József–Kővári Attila–Ujbányi Tibor A destruktor avagy az objektumpéldány megszüntetése 13 39 IT-biztonság egy gráf alapú modellje Mintapélda 14 Galéria Paraméterezett típusok 15 (Somorácz György fotói) 48 Függvénysablonok, függvény felüldefiniálások 15 Mintapélda 16 19 Osztálysablonok 19 Mintapélda Gyakorló példák 20 2. Forráskódok Művelet osztály deklarációja (Muvelet.h) 25 Művelet osztály implementálása (Muvelet.cpp) 26 Művelet osztály példányosítása (main.cpp) 27 Rectangle osztály deklarációja (Rectangle.h) 28 Rectangle osztály példányosítása (main.cpp) 30 Swap osztály deklarációja (Swap.h) 30 Dunakavics  –  2014 / 7. 6.

Tartalom Swap osztály implementálása (Swap.cpp) Swap osztály példányosítása (main.cpp) OSwap osztály deklarációja (OSwap.h) OSwap osztály implementálása (OSwap.cpp) Nagy Bálint OSwap osztály példányosítása (main.cpp) Trajektóriák ábrázolása TSwap osztály deklarációja (TSwap.h) Katona József–Kővári Attila–Ujbányi Tibor TSwap osztály implementálása (TSwap.cpp) Agy-számítógépek interfészek rendszerbe történő illesztése TSwap osztály példányosítása (main.cpp) Katona József–Kővári Attila–Ujbányi Tibor TGetMax osztály deklarációja (TGetMax.h) IT-biztonság egy gráf alapú modellje TGetMax osztály implementálása (TGetMax.cpp) TGetMax osztály példányosítása (main.cpp) Galéria (Somorácz György fotói)

31 32 33 34 35 5 36 36 29 37 38 39 38 39 48

3. Felhasznált irodalom

40

Előszó Úgy gondoljuk, hogy ez a könyvsorozat hozzájárulhat ahhoz is, hogy különböző szakemberek vagy akár középiskolai diákok is kamatoztathassák tudásukat a témában. A műsorozat elsődleges célja az objektumorientált világ megismertetése. Az ismeretek elsajátításhoz igyekeztünk egy olyan magas szintű programozási nyelvet választani, amely az előismeretekre támaszkodva hatékonyan képes szemléltetni az OOP világában használt szabályokat, fogalmakat, elveket és modelleket. A választott C++ nyelv mindamellett, hogy a fentebb leírt előírásoknak megfelel, a munkaerőpiacon is az egyik legsikeresebbnek számító magasszintű nyelv. A szoftverfejlesztési és annak tanítási tapasztalataink alapján arra az elhatározásra jutottunk, hogy a választott C++ nyelvet nem a legelejétől kívánjuk ismertetni. Nem szeretnénk például elismételni azokat a vezérlési szerkezeteket, amelyeket már egy középszinten lévő programozó számtalanszor hallott és jó eséllyel használt. Természetesen ez nem azt jelenti, hogy ezeket az eszközöket el is felejthetjük, ugyanis, ahhoz, hogy jó programozó váljon belőlünk nem elég ismernünk ezeket az utasításkészleteket, hanem fel is kell ismernünk, hogy hol és mikor a legcélszerűbb azokat használni. A könyv összeállításakor az ipari és oktatói tapasztalatainkra és számos, neves szakirodalomra támaszkodtunk. Reméljük, hogy ez a mű hozzásegíti az olvasót a tananyag megértéséhez és könnyed elsajátításához. Ehhez kellő kitartást és lelkesedést kívánunk. Köszönettel tartozunk a kézirat lektorának, Dr. Kusper Gábornak gondos munkájáért, szakmai tanácsaiért és módszertani javaslataiért, melyek jelentősen hozzájárultak a könyvsorozat magasabb szakmai szintre emeléséhez.

A Szerzők

OOP: angolul object-oriented programming egy programozási módszertan

7



Katona József r−Király Zoltán rr

Objektumorientált programozás C++ nyelven

(Konstruktor típusok, Destruktor, Osztálysablonok, Függvénysablonok és Függvénytúlterhelések) 1. Fejezet A konstruktor típusok A konvencionális programozási nyelvek széles körű problémája az úgynevezett inicializálás vagy más néven kezdetiérték-adás. A programozó által létrehozott adattípusoknak ugyanolyan integráns részei egy programnak, mintha beépített típusok lennének, ez a C++ filozófiájának egyik lényeges eleme. Ebből kiindulva a C++ tervezői és megalkotói egy speciális függvényt hoztak létre, amely egyértelműen meghatározzák, hogy milyen módon fogalmazhatóak meg egy adott osztály objektumai. Ezt a speciális függvényt konstruktornak nevezzük. Az eddigi programok megoldása során, ha szükség volt konstruktorra, akkor annak a paraméteres alakját használtuk, ahol a konstruktor a paraméterben kapott értékeket adta értékül az osztály adattagjainak. Az előző könyvben a konstruktort egy olyan speciális függvénynek tekintettük, melynek a törzsében lévő kód akkor fut le, amikor az adott osztályból létrehozunk egy példányt. A konstruktor általános feladata az osztály adattagjainak inicializálása. A legfontosabb tulajdonságai a következőek: − A neve meg kell, hogy egyezzen az Osztály nevével. − Nincs visszatérési értéke, még void sem. − Mint minden más metódus a konstruktor is túlterhelhető, így eltérő paraméterezésű konstruktor is létrejöhet. − Ha nincs általunk létrehozott konstruktor, akkor a fordító elkészíti az alapértelmezett konstruktort. − Nem öröklődhet.

Dunaújvárosi Főiskola, Informatika Intézet E-mail: [email protected] r

Dunaújvárosi Főiskola, Informatika Intézet E-mail: [email protected] rr

9

elengedhetetlen a szükséges memória terület lefoglalása, vagy akár eg hálózati erőforrás kapcsolódásáért is felelhet. Katona József−Király Z oltán

Alapértelmezett konstruktor (default constructor) Az adattagok inicializálása mellett gyakorta további feladatokat is ellát. Az olyan osztályoknál, amelyek memóriaigénye nagyobb, elengedhetetlen a szükséges memóriaterület lefoglalása. A paraméteres konstruktor mellett létezik paraméter nélküli i

amelyet alapértelmezett konstruktornak (default) nevezünk. Az ilye Alapértelmezett konstruktor (default constructor) típusú konstruktor törzsében általában az osztály adattagjait látjuk

A paraméteres konstruktor mellett létezik paraméter nélküli is, amelyet konstruktornak konstans kezdőértékkel. Azalapértelmezett alábbi példa egy alapértelmeze (default) nevezünk. Az ilyen típusú konstruktor törzsében általában az osztály adattagjait látjuk el konsahol egy (Komplex) k tans kezdőértékkel. Az alábbi példa egykonstruktor alapértelmezettfelépítését konstruktorillusztrálja, felépítését illusztrálja, aholosztály egy osztály (Komplex) két változóját (re, im) konstans nulla értékkel látjuk el: változóját (re, im) konstans nulla értékkel látjuk el: Komplex  ::  Komplex()   {     this-­‐>re=0;  this-­‐>im=0;   }   másolókonstruktor is képes arra, amire az

összes többi: létrehozáskor

inicializálhatjuk vele az objektumainkat. A másoló konstruktor

paraméterének nélkülözhetetlen velejárója, hogy az referencia legyen, Másoló konstruktor (copy constructor) különben végtelen ciklus keletkezik, mert a paraméterátadáshoz is a A konstruktorok világában létezik egy harmadik típus, amelyet(copy másoló konstruktornak nevezünk (copy Másoló konstruktor constructor) másolóhasználva konstruktort használjuk. Az alábbiakban példát constructor). Ezt a függvénytípust egy objektumpéldánynak, kezdőértéketláthatunk adhatunk egy már egy létező és inicializált másik objektumpéldánnyal. A másolókonstruktor képes arra, amire az összes többi: másoló konstruktor implementálására, ahol Komplex osztályhoz A konstruktorok világában islétezik egyaharmadik típus, amelyet máso létrehozáskor inicializálhatjuk vele az objektumainkat. A másoló konstruktor paraméterének nélkülözhetartozó másolókonstruktor paramétere egyconstructor). ugyanolyan típusú konstruktornak (copy Ezt a típus tetlen velejárója, hogy az referencia legyen, különben végtelennevezünk ciklus keletkezik, mert a paraméterátadáshoz is a másoló konstruktort használjuk. Az alábbiakban láthatunkegy egy objektumpéldánynak példát a másoló konstruktor implereferencia: függvényt használva kezdőértéket adhatun mentálására, ahol a Komplex osztályhoz tartozó másolókonstruktor paramétere egy ugyanolyan típusú egy már létező és inicializált másik objektumpéldánnyal. refe-rencia:   Komplex  ::  Komplex(const  Komplex  &object)   {   6   this-­‐>re=object.re;  this-­‐>im=object.im;   }  

Az osztály nem csak egy konstruktort tartalmazhat, hanem többet is, és mindig az argumentumlista Az osztály csak egy konstruktort tartalmazhat, hanem többet is, és alapján dől el, hogy melyik változat kerülnem felhasználásra. mindig az argumentumlista alapján dől el, hogy melyik változat kerül

10

felhasználásra.

Objektumorientált programozás C++ nyelven Mintapélda

Mintapélda Írjunk

egy

olyan

osztályt,

amelynek

van

egy

paraméteres konstruktora. A konstruktoron Írjunk egy Művelet osztályt, alapértelmezett, Írjunk egy Muveletahol osztályt, ahol parakeresztül adjunk át egy rövidebb szöveget. A méteresalapértelmezett, és másoló konstruktor is szerepel. felaparaméteres és Az máosztály soló konstruktor feladata legyen az osztály adattagjának data a konstruktor négy alapvető művelet közül az egyik elvégzése és szerepel. Az osztály felaadata a inicializálása. Azisosztály legyen képes következő eredményének kiíratása. Az alapértelmezett konstrukadatokat magánhangzók, nég y al apvetőszolgáltatni: művelet közül az egyik elvégzése mássalhangzók és szóközök száma. Az osztály egy tornál és válasszuk az összeadást, aa paraméteres konstrukaz eredményének kiíratása. Az függvénye cserélje le a szóközöket #-re. Az egyes tornál a felhasználó döntse el, hogy milyen műveletet szalapértelmezett konstruktornál vál asszuk az műveletek végrehajtásához külön függvényeket eretne végezni. A másolókonstruktor feladata értéke pedig, hogy használjon, amelyeknek visszatérési a összeadá st, a paraméteres konstruktornál a a feladattól paraméteresfügg. példánynál felhasznált értékeket másolja Az osztály függvényeinek ale felhaszná ló döntse el, hogy milyen műveletet objektumon keresztül végezze. Az ésmeghívását végezze el ugyanazt a műveletet. (CA_03) eredményt konzolos szemléltesse. szeretneegyvég ezni. A kiíratással másolókonstruktor

 

(CA_02) Ez felada ta a

sor nekem nem fér ki!!! pedig a paraméteres példánynál

felhaszná lt értékeket máso lja le és végezze el Osztálydiagram (Class diagram)

Osztálydiagram (Class diagram)

 

 

 

 

8

11

Katona József−Király Z oltán Objektumdiagram (Object diagram)

Objektumdiagram (Object diagram)

 

Az osztály deklarációját a (Muvelet.h) állományban adjuk meg. A Muvelet osztály magán adattagjai: Ø

double

x,y

az operandusok;

Ø

double

eredmeny

tárolja a művelet eredményét;

Ø

char

a (Muvelet.h) állományban adjuk meg. A muvAz osztály deklarációját a műveleti jelet tartalmazza Muvelet osztály magán adattagjai:

 

muv operátor alapján kiválasztott műveletet végrehajtsa, és Az osztály deklarációját a (Muvelet.h) adjukazmeg. A Muvelet osztály magán adattagjai: Ø double állományban x,y operandusok; A Muvelet osztály nyilvános tagfüggvényei: az eredményt az eredmeny adattagban tárolja. − double x,y az operandusok; Ø double eredmeny tárolja a művelet eredményét; eredmenyközlése tárolja aa művelet eredményét; feladata: Ø − double Az eredmény Kiir() tagfüggvény char jelet tartalmazza charművelet muv a műveleti jeletØtartalmazza; Ø − A végrehajtását, azaz amuv számítást aa műveleti Szamol() void Kiir(); A Muvelet osztály nyilvános tagfüggvényei: tagfüggvény végzi: A Muvelet osztály nyilvános tagfüggvényei: − A művelet végrehajtását, azaz a számítást a Szamol() tagfüggvény végzi: Ø A Kiir() tagfüggvénynek az adattagokban tárolt adatokat void Szamol(); muv operátor alapján Økiválasztott műveletet végrehajtsa, és a Szamol() A művelet azaz ahiszen számítást ki aszöveges formában. − írja Ennek void típusú függvénynek nincsvégrehajtását, paraméterlistája, az objektum adattagjait használja a Ø műveletvégzéshez. Ennek a void típusú függvénynek nincs paraméterlistája, végzi: Szamol() tagfüggvény tagfüggvény feladata, az eredményt azA eredmeny adattagban tárolja.hogy a muv operátor alapján kiválasztott műveletet Szamol(); végrehajtsa, ésaz az eredményt azvoid eredmeny adattagban tárolja. hiszen objektum adattagjait használja a Az eredmény közlése a készítettünk: Kiir() tagfüggvény feladata: Három Ø eltérő típusú konstruktort − Az eredmény közlése a Kiir() tagfüggvény feladata: Ø Ennek a void típusú függvénynek nincs paraméterlistája, műveletvégzéshez. void Kiir(); A Szamol() tagfüggvény feladata, hogy a hiszen az objektum adattagjait használja a A Kiir() tagfüggvénynek az adattagokban adatokat írja ki szöveges formában. Ø − A paraméter nélkülit, ahol az tárolt adattagokat konstans Ø Kiir() tagfüggvénynek az adattagokban tárolttagfüggvény adatokat műveletvégzéshez. A Szamol() feladata, hogy a Három eltérő típusú konstruktort készítettünk: kezdőértékkel látjuk el:az adattagokat konstans kezdőértékkel látjuk el: − írja A paraméter nélkülit, ahol ki szöveges formában. 9 Muvelet() {x=1; y=1; muv='+';} 9

Három eltérő típusú konstruktort készítettünk: Ø12A paraméterest, ahol a paraméterben kapott értékekkel Ø

látjuk el az osztály adattagjait. A paraméter nélkülit, ahol az adattagokat konstans

A paraméterest, ahol a paraméterben kapott értékekkel Muvelet() {x=1; y=1; muv='+';} látjuk el az osztály adattagjait. Objektumorientált programozás C++ nyelven Muvelet(double x1, double y1, kapott char muv1); Ø A paraméterest, ahol a paraméterben értékekkel Ø

látjuk el az osztály adattagjait. paraméterest, ahol a paraméterben értékekkel látjuk el az osztály adattagjait. Ø − A Másoló konstruktort, ahol egykapott másik objektumpéldány Muvelet(double x1, double y1, char muv1); értékeivel látjuk el az objektumpéldányt. − Másoló konstruktort, ahol egy másik objektumpéldány értékeivel látjuk el az objektumpéldányt. Muvelet(const Muvelet &v); Ø Másoló konstruktort, ahol egy másik objektumpéldány A (Muvelet.cpp) állomány tartalmazza az osztály tagfüggvényeinek kidolgozását. A tagfüggvény neve értékeivel látjuk el az használjuk objektumpéldányt. előtt a :: állomány hatókör-operátort hogytagfüggvényeinek jelezzük melyik osztály A (Muvelet.cpp) tartalmazza az arra, osztály a tagfüggvényét akarjuk kifejteni. A (main.cpp) állományMuvelet tartalmazza&v); a main() függvényt. A függvény kifejtése előtt szükséges a (Muvelet.h) Muvelet(const kidolgozását. A tagfüggvény neve benne előtt találhatóak a :: hatókör fejlécállomány beépítése, hiszen a Muveletoperátort osztály deklarációi. A főfüggvényben történő példányosítás után hívjuk meg a szükséges függvényeket. Az strchr() használjuk arra, állomány hogy jelezzük melyik osztály tagfüggvényét óhajtjuk A (Muvelet.cpp) tartalmazza az osztály tagfüggvényeinek a függvény az m karakter +-*/ beli első előfordulási helyének mutatójával, illetve, ha m nem található meg +-*/-ban, akkor NULL értékű kifejteni. „mutatóval” kidolgozását. A tagfüggvény tér vissza. neve előtt a :: hatókör operátort használjuk arra, hogy jelezzük melyik osztály tagfüggvényét óhajtjuk A (main.cpp) állomány tartalmazza a main() függvényt. A függvény kifejteni.

A destruktor avagy az objektumpéldány megszüntetése

kifejtése előtt szükséges a (Muvelet.h) fejlécállomány beépítése, hiszen Az eddigi példákban a memóriát, mint statikus eszközt kezeltük. Ez azt jelentette, hogy az objektumbenne találhatóak a Muvelet osztály deklarációi. A főfüggvényben A (main.cpp) állomány tartalmazza a main() függvényt. A függvény példányt létrehoztuk, de a példány megszüntetését magára az operációs rendszerre bíztuk. Tehát a destruktor, azszükséges objektum megszüntetésért, aamemória felszabadításáért felelős, történő példányosítás után hívjuk megfejlécállomány szükséges függvényeket. Az amely eddig automatikusan került kifejtése előtt a (Muvelet.h) beépítése, hiszen meghívásra. Azonban vannak olyan esetek, amikor a memóriát célszerűbb dinamikusan kezelni, tehát benne találhatóak a Muvelet deklarációi. A főfüggvényben maga a programozó szabjaosztály meg, hogy egy objektumpéldány meddig létezzen. Néhány fontosabb tulajdonság, amely igazután a destruktorra: történő példányosítás hívjuk10meg a szükséges függvényeket. Az − A destruktor nevét a hullám karakterrel (~) kell kezdeni. − A konstruktorhoz hasonlóan a neve megegyezik az osztály nevével. − A konstruktorhoz hasonlóan 10 itt sincs vissza térési érték, még void sem. − Ha az osztály rendelkezik destruktorral, akkor azt hívja meg a fordító, ha azonban ilyen nem létezik, akkor az adott osztályhoz a fordító a saját alapértelmezése szerinti változatát használja. − A destruktor aktivizálása a delete operátorral történik. − Egy destruktor lehet virtuális is, azonban egy konstruktor nem.

13

Katona József−Király Z oltán Mintapélda

Mintapélda Írjunk

Osztálydiagram (Class diagram )

egy

olyan

paraméteres

osztályt,

amelynek

konstruktora.

A

van

egy

konstruktoron

Készítsünk osztályt, melynek feladata egy téglalap kerületének és területének a kiszámolása. A memóriát dinamikusan kezeljük. (CA_04) keresztül

adjunk

konstruktor

feladata

inicializálása.

Az

adatokat

rövidebb

szöveget.

az

adattagjának

osztály

legyen

és

szóközök

feladattól

Ez

Mintapélda

a

képes

Az

a

konzolos

sor

Az

Az

visszatérési

értéke

függvényeinek

keresztül

nem

egy

egyes

függvényeket

végezze.

kiíratással

nekem

A

következő

osztály

#-re.

külön

osztály

objektumon

egy

a

magánhangzók,

száma.

szóközöket

amelyeknek

függ.

meghívását eredményt

le

végrehajtásához

használjon,

(CA_02)

legyen

osztály

cserélje

műveletek

 

egy

szolgáltatni:

mássalhangzók függvénye

át

fér

a

a

Az

szemléltesse.

ki!!!

Osztálydiagram diagram ) Osztálydiagram(Class (Class diagram)

Készí tsünk osztályt, melynek feladata egy tégla lap

kerületének

kiszámolása.

A

és

területének

memóriát

a

dinamikusan

kezeljük. (CA_04) Objektumdiagram (Object diagram) Objektumdiagram diagram) Készí tsünk osztályt, (Object melynek feladata egy

tégla lap

kerületének

kiszámolása.

A

és

területének

memóriát

a

dinamikusan

kezeljük. (CA_04) A (Rectangle.h) állomány tartalmazza az osztály deklarációit, azonban Objektumdiagram (Object diagram) itt a függvények is az kifejtése kerülnek, ezért külön implementációs fájlra is kifejtése kerülnek, A (Rectangle.h) állomány tartalmazza osztály deklarációit, azonban itt a függvények

ezért külön implementációs fájlra nincs include afájlokra már fentebb megírt programoknál nincs szükség. Az szükség. includeAzfájlokra már afentebb megírt használt műveletek miatt van szükség. Ahhoz, hogy a cout és a cin függvényeket elérjük, szükség van az programoknál használt műveletek miatt van szükség. Ahhoz, hogy a úgynevezett std névtérre. Ennek behívása történik a using kulcsszóval. Az osztályunk neve Rectangle. A példánkban a téglalap magasságát és szélességét adattag-mutatókban tároljuk. Az adattag-mutatók egyszeres indirektségű mutatóként viselkednek, azaz12egy memóriacímre hivatkoznak. A (Rectangle.h) állomány tartalmazza az osztály deklarációit, azonban

14

itt a függvények is kifejtése kerülnek, ezért külön implementációs fájlra nincs

szükség.

Az

include

fájlokra

a

már

fentebb

megírt

programoknál használt műveletek miatt van szükség. Ahhoz, hogy a

Objektumorientált programozás C++ nyelven Az osztály konstruktora a new operátor segítségével lefoglalja a memóriaterületet a két adattag-mutató számára, ahol átadásra kerül a téglalap magassága és szélessége. Az osztály két egyszerű feladatát a District() és az Area() függvény látja el, továbbá a konzolos információ megjelenítésért a Printer() függvény felel. Az utolsó függvényünk a destruktor, amely majd a memóriaterület felszabadításáért lesz felelős, illetve további feladata az adattag-mutatók által foglalat memóriaterület felszabadítása, amely a delete operátorral történik. Abban az esetben, ha a függvény feladatát nem az osztály deklarációján kívül fejtjük ki inline módszernek nevezzük. Az inline módszert kisterjedelmű függvényeknél érdemes használni, mert ebben az esetben olyan, mintha makró lenne, tehát a függvényhívásokkal járó adminisztrációra nincs szükség. Rövid, egy-két soros függvények esetében ez sokkal hatékonyabb, sokkal olvashatóbb megoldást jelent. A fő függvényünkben (main.cpp) a Rectangle egy példányát (objektumát) dinamikusan hozzuk létre. Mi saját magunk memóriát foglalunk le az objektum (példány) részére, és már lehet is vele műveletet végezni. A new operátorral hívjuk a konstruktort és adjuk át neki az értékeket. Az osztály public láthatóságú tagjaira „->” operátorral hivatkozunk. A példány megsemmisülése általunk vezérelten fog történni, nem lesz automatikus. Az objektum mindaddig foglalt marad, amíg azt fel nem szabadítjuk a delete operátor segítségével. Egy osztályból tetszőleges példányt (ameddig a memória bírja) hozhatunk létre.

Paraméterezett típusok A sablonok (template) használata lehetővé teszi, hogy egymással logikai kapcsolatban álló függvények és osztályok családját hozzuk létre. A C++ sablonok tulajdonképpen a generikus típusok C++ nyelvbeli megfelelői. Az osztályok és függvények akkor válnak teljessé, ha azok hívásra kerülnek. A nagy keretrendszer-fejlesztők szeretik a sablonokat, ugyanis, ha például egy függvényt fel szeretnénk használni több típussal (integer, double, char, string, bool stb.), akkor minden egyes típusnál új metódust kell írnunk, azonban a sablonok használatával elég azt csak egyszer megírnunk és a híváskor átadni neki azt a típust, amivel dolgozni szeretnénk. Függvénysablonok, függvény felüldefiniálások Ha olyan függvényt szeretnénk használni, ami különböző típusú paraméterekkel dolgozik, akkor azt úgy tehetjük meg, hogy külön minden típushasználatakor írunk egy új függvényt. Egy másik sokkal szebb megoldás a függvény-felüldefiniálás, ahol is az átdefiniálás során a függvény törzse szinte nem változik. Továbbá a C++ lehetőséget ad úgynevezett sablonok használatára, ahol is elég a függvényt egyszer megírni és a továbbiakban az bármilyen típussal el fog boldogulni.

15

Katona József−Király Z oltán Mintapélda

Az eddig megismert fogalmak segítségével oldjunk meg egy olyan feladatot, ahol adatcsere-függvények fognak szerepelni, amelyek felcserélnek két egész, valós és karaktertípusú változó tartalmát. (CA_05) A továbbiakban ezt a problémát oldjuk meg függvény-túlterheléssel. (CA_06) Végezetül nézzük meg, hogyan is nézne ki a feladat függvénysablon segítségével. (CA_07) Írjunk

egy

olyan

paraméteres keresztül

osztályt,

amelynek

konstruktora.

adjunk

át

egy

A

van

egy

konstruktoron

rövidebb

szöveget.

A

konstruktor feladata legyen az osztály adattagjának inicializálása.

Az

adatokat

osztály

legyen

képes

szolgáltatni:

a

következő

magánhangzók,

mássalhangzók és szóközök száma. Az osztály egy függvénye

cserélje

műveletek

használjon, feladattól

eredményt (CA_02)

a

szóközöket

amelyeknek

függ.

meghívását

 

le

végrehajtásához Az

egy

konzolos

Az

egyes

függvényeket

visszatérési

osztály

objektumon

#-re.

külön

értéke

függvényeinek

keresztül

kiíratással

végezze.

Mintapélda

Osztálydiagram (Class diagram) (Class diagram )

Osztálydiagram class Class Model

Sw ap CharSwapper(char&, char&) : void FloatSwapper(float&, float&) : void IntegerSwapper(int&, int&) : void Swap(void) ~Swap(void)

Objektumdiagram (Object diagram)

Objektumdiagram (Object diagram) class Class Model

sw apObj ect:Sw ap

Az eddig oldjunk

- c1: char = * - c2: char = # - f1: float = 1.5 - f2: float = 2.8 - i1: int = 10 megismert - i2: int fogalmak = -4

meg

egy

olyan

segítségével

feladatot,

ahol

Azadatcsere osztály deklarációját a (Swap.h) állományban adjuk meg. A függvény ek fognak szerepelni, különböző típusú adatok cseréjéhez külön függvényeket írunk, amelyek

16

a

Az

szemléltesse.

Ez a sor nekem nem fér ki!!!

+ + + + +

a

amely ek felcserélnek két egész, valós és

a paraméterben kapott értékek csere végrehajtásáért lesznek felelősek.

karakter típusú v áltozó tartal mát. (CA_05)

A (Swap.cpp) állomány tartalmazza az osztály tagfüggvényeinek a

A to vábbiakban ezt aneve problémát kidolgozását. A tagfüggvény előtt a :: oldjuk hatókör meg operátort

különböző típusú adatok cseréjéhez külön függvényeket írunk, amelyek a paraméterben kapott értékek csere végrehajtásáért lesznek felelősek. A (Swap.cpp) állomány tartalmazza az osztály tagfüggvényeinek a

Objektumorientált programozás C++ nyelven

kidolgozását. A tagfüggvény neve előtt a :: hatókör operátort használjuk arra, hogy jelezzük melyik osztály tagfüggvényét óhajtjuk

Az osztály deklarációját a (Swap.h) állományban adjuk meg. A különböző típusú adatok cseréjéhez külön kifejteni. A (main.cpp) állomány tartalmazza a main() függvényt. A függvényeket írunk, amelyek a paraméterben kapott értékek csere-végrehajtásáért lesznek felelősek. A előtt szükséges a (Swap.h) fejlécállomány beépítése, hiszen (Swap.cpp) állományfüggvény tartalmazza az osztály tagfüggvényeinek a kidolgozását. A tagfüggvény neve előtt a :: benne találhatóak a Swap osztály deklarációi. A main-ben történő hatókör-operátort használjuk arra, hogy jelezzük melyik osztály tagfüggvényét óhajtjuk kifejteni. A (main. cpp) állomány tartalmazza a main() függvényt. A függvény előtt szükséges (Swap.h) fejlécállomány példányosítás után hívjuk meg a szükséges függvényeket. Nézzünkameg beépítése, hiszen benne találhatóak a Swap osztályahol deklarációi. main-ben fogjuk történő példányosítás után egy másik megoldási módszert, a függvényA túlterhelést hívjuk meg a szükséges függvényeket. Nézzünk meg egy másik megoldási módszert, ahol a függvényalkalmazni. túlterhelést fogjuk alkalmazni. Osztálydiagram (Class diagram ) Osztálydiagram class Class Model (Class diagram) OSw ap + + + + +

OSwap(void) ~OSwap(void) Swapper(int&, int&) : void Swapper(float&, float&) : void Swapper(char&, char&) : void

Objektumdiagram (Object diagram)

Objektumdiagram (Object diagram) class Class Model 16 osw apObj ect:OSw ap -

c1: c2: f1: f2: i1: i2:

char = * char = # float = 1.5 float = 2.8 int = 10 int = -4

Az osztály deklarációját az (OSwap.h) állományban adjuk meg. A különböző típusú adatok cseréjéhez küAz osztály deklarációját az (OSwap.h) állományban adjuk meg. A lön függvényeket írtunk, amelyek a paraméterben kapott értékek cserevégrehajtásáért felelősek. A különbkülönböző típusú adatok cseréjéhez külön függvényeket írtunk, ség viszont az, hogy itt már azonos nevű függvényeket használunk. Az (OSwap.cpp) állomány tartalmazza amelyek a paraméterben kapott értékek csereelőtt végrehajtásáért felelősek. az osztály tagfüggvényei kidolgozását. A tagfüggvény neve a :: hatókör-operátort használjuk arra, hogy jelezzük melyikA osztály tagfüggvényét kifejteni. (main.cpp) állomány tartalmazza a különbség viszont az, szeretnénk hogy itt már azonos A nevű függvényeket main() függvényt. Ahasználunk. függvény előtt az (OSwap.h) fejlécállomány hiszen benne taAz szükséges (OSwap.cpp) állomány tartalmazza az beépítése, osztály lálhatóak az OSwap osztály deklarációi. A mainben történő példányosítás után hívjuk meg a szükséges tagfüggvényeinek a kidolgozását. A tagfüggvény neve előtt a :: hatókör függvényeket. operátort használjuk arra, hogy jelezzük melyik osztály tagfüggvényét

szeretnénk kifejteni. A (main.cpp) állomány tartalmazza a main() függvényt. A függvény előtt szükséges az (OSwap.h) fejlécállomány beépítése, hiszen benne találhatóak az OSwap osztály deklarációi. A

17

függvényt. A függvény előtt szükséges az (OSwap.h) fejlécállomány beépítése, hiszen benne találhatóak az OSwap osztály deklarációi. A

Z oltán main-benKatona történő József−Király példányosítás után hívjuk meg a szükséges függvényeket.

A

következő

példában

az

adatcsere

függvény

A következő példában az adatcsere sablonnal függvénytörténő paramétereinek sablonnal történő megoldása szerepel. paramétereinek megoldása szerepel. Osztálydiagram (Class diagram )

Osztálydiagram (Class diagram)

class Class Model

T:class TSw ap + + +

swapper(T&, T&) : void TSwap(void) ~TSwap(void)

17 Objektumdiagram (Object diagram) Objektumdiagram (Object diagram) class Class Model *tsw apObj ect1:TSw ap -

i1: = 10 i2: = -4

*tsw apObj ect2:TSw ap -

f1: = 1.5 f2: = 2.8

*tsw apObj ect3:TSw ap -

c1: = * c2: = #

Az osztály deklarációját a (TSwap.h) állományban adjuk meg. A szükséges paramétereket az osztályok és meg. a tagfüggvények kell Az osztály deklarációját a (TSwap.h) állományban adjuk A szükségeselé paramétereket az osztályok és a tagfüggvények elé kell beszúrni, valamint a paraméterek típusát is jelölni kell. A csere végrehajtásához beszúrni, valamint a paraméterek típusát is jelölni kell. A csere itt már csak egyetlenvégrehajtásához függvényt kellittmegírnunk és az típustól tud és feladatot végrehajtani. A már csak egyetlen függvénytfüggetlenül kell megírnunk az (TSwap.cpp) állomány tartalmazza az osztály tagfüggvényeinek a kidolgozását. A tagfüggvény neve előtt típustól függetlenül tud feladatot végrehajtani. A (TSwap.cpp) állomány a :: hatókör-operátort használjuk arra, hogy jelezzük melyik osztály tagfüggvényét óhajtjuk kifejteni. A tagfüggvényeinek a kidolgozását. A tagfüggvény (main.cpp) állománytartalmazza tartalmazzaazaosztály main() függvényt. Itt az osztályon kívül fejtjük ki a függvényeket és a neve előtt hatókör operátort használjuk arra, hanem hogy jelezzük sablonok használata miatt nema a:: .h kiterjesztésű fájlt kell behívni, a .cppmelyik kiterjesztésűt. A mainben történő példányosításosztály után hívjuk meg a szükséges A példány megszüntetéséhez használjuk tagfüggvényét óhajtjuk függvényeket. kifejteni. A (main.cpp) állomány a delete operátort. tartalmazza a main() függvényt. Itt az osztályon kívül fejtjük ki a

18

függvényeket és a sablonok használata miatt nem a .h kiterjesztésű fájlt kell behívni, hanem a .cpp kiterjesztésűt. A main-ben történő példányosítás után hívjuk meg a szükséges függvényeket. A példány

cha

Objektumorientált programozás C++ nyelven A típussablonnal paraméterezett osztály (generic class), lehetővé

Osztálysablonok

teszi, hogy más osztályok definiálásához a paraméterezett osztályt

A típussablonnal paraméterezett class), lehetővé teszi, hogy más osztályok definiáÍrjunk osztály olyan(generic osztálysablont, amely lásához felhasználjuk a paraméterezett osztályt, ezáltal egy adott osztálydefiníció minden típus esetén alkét tetszőleges típusú adatról kalmazható lesz. Tehát tetszőleges az osztály példányosítása során átadjuk azt a típust, amellyel szeretnénk használni az osztályunkat, majd ha más típussal szeretnénk tovább dolgozni, akkor nincs képes el dönteni, hogy melyik a nagyobb.más teendő, mint új objektumpéldány létrehozása és a megfelelő típus átadása. (CA_08) felhasználjuk, ezáltal egy adott osztálydefiníció minden típus esetén Írjunk

egy

olyan

osztályt,

amelynek

van

alkalmazható lesz. Tehát az osztály példányosítása során átadjuk azt a

egy

Írjunk olyan osztálysablont, amely két tetszőleges típusú típust, amellyel szeretnénk használni az osztályunkat, majd ha más adatról képes eldönteni, hogy melyik a nagyobb. (CA_08) típussal szeretnénk tovább dolgozni, akkor nincs más teendő, mint új paraméteres keresztül

konstruktora.

adjunk

konstruktor

inicializálása.

Az

adatokat

egy

osztály

A

konstruktoron

rövidebb

legyen

az

függvénye

és

legyen

szóközök

cserélje

műveletek feladattól

le

a

képes

száma.

szóközöket

amelyeknek

függ.

eredményt

Az

(CA_02)

Ez

a

konzolos

sor

Az

osztály Az

nem

fér

egy

egyes

függvényeket értéke

függvényeinek

keresztül

kiíratással

nekem

következő

#-re.

külön

osztály

objektumon

egy

a

visszatérési

objektumpéldány létrehozása és a megfelelő típus átadása.

meghívását

A

adattagjának

magánhangzók,

végrehajtásához

használjon,

szöveget.

osztály

szolgáltatni:

mássalhangzók

 

át

feladata

végezze.

a

a Az

szemléltesse.

ki!!!

Mintapélda

Mintapélda Osztálydiagram (Class Osztálydiagram (Classdiagram diagram)) class Class Model

T:class TGetMax -

a: T b: T

+ + +

GetMax() : T TGetMax(T, T) ~TGetMax(void)

Objektumdiagram (Objectdiagram) diagram) Objektumdiagram (Object class Class Model

tGetMaxObj ect:TGetMax -

a: = 100.23 b: = 75.34

19 Az osztály deklarációját az (TGetMax.h) állományban adjuk meg. A szükséges paramétereket az osztályok és a tagfüggvények elé kell beszúrni,

valamint

a

paraméterek

típusát

is

jelölni

kell.

A

konstruktorunk paraméteres, ahol két darab T típusú adatot vár

19

Katona József−Király Z oltán Az osztály deklarációját az (TGetMax.h) állományban adjuk meg. A szükséges paramétereket az osztályok és a tagfüggvények elé kell beszúrni, valamint a paraméterek típusát is jelölni kell. A konstruktorunk paraméteres, ahol két darab T-típusú adatot vár paraméterül. A GetMax() függvény egy T-típusú adatot ad vissza a destruktor pedig a memória felszabadításért lesz felelős. A (TGetMax.cpp) állomány tartalmazza az osztály tagfüggvényeinek a kidolgozását. A tagfüggvény neve előtt a :: hatókör-operátort használjuk arra, hogy jelezzük melyik osztály tagfüggvényét szeretnénk kifejteni. A (main.cpp) állomány tartalmazza a main() függvényt. A mainben történő példányosítás után hívjuk meg a szükséges függvényeket. A példányosítás során átadjuk a típust, amellyel az osztályt szeretnénk használni.  

Gyakorló példák

Gyakorló példák Gyakorló példák

Írjunk

egy

olyan

osztályt,

amelynek

van

egy

Írjon egy Simple osztályt, melynek egy konstruktora Írjo n eg y osztály t, S imple, melynek e gy van és kiírja, meghívják. Írjon amikor egy o sztá lyt, S imple,A main() mely nek függvényben e gy ko nstru kto ra va n és kiírja , a mik or me gh ívják. A deklaráljunk egy Simple-objektumot. A deklarált konstru ktora v an és kiírja, a mik or me gh ívják. A objekm a in () függ vény ben d eklar áljun k e gy Simple tumot egészítsük egy szintén csak m a in () függki vény bendestruktorral, d eklar áljun k emely gy Simple o bjek tum o t. A dek la rált ob jektumot egészítsü k egy üzenetet ír oki. o bjek tum t. (GYF_CA_05) A dek la rált ob jektumot egészítsü k paraméteres keresztül

konstruktora.

adjunk

konstruktor

Az

egy

legyen

osztály

rövidebb

szöveget.

adattagjának

szolgáltatni:

mássalhangzók

és

cserélje

műveletek

használjon, feladattól

meghívását

szóközök le

a

amelyeknek Az

osztály

képes

Az

külön

Az

keresztül

egy

egyes

függvényeket értéke

függvényeinek végezze.

a

a

Az

ki eg y egy destruk to rral, mely szin tén c sak e gy eredményt konzolos kiíratással szemléltesse. (CA_02) sor torra nekem nem férc sak ki!!! ki Ez egy adestruk l, mely szin tén e gy üze netet ír ki. (G YF _CA _0 5) üze netet ír ki. (G YF _CA_ 0 5) Osztálydiagram diagram ) Osztálydiagram(Class (Class diagram) Osztálydiagram (Class diagram )

Objektumdiagram (Object diagram) Objektumdiagram diagram) Objektumdiagram (Object (Object diagram)

20

A

következő

osztály

#-re.

visszatérési

osztály

objektumon

a

magánhangzók,

száma.

szóközöket

végrehajtásához

függ.

konstruktoron

az

legyen

adatokat

függvénye

 

át

feladata

inicializálása.

A

Objektumorientált programozás C++ nyelven Írjo n

e gy

osz tály t,

Vona l,

me lynek

egy

nstruolyan kto ra vanosztályt, é s kiírja , egy hog ykonstruktora " Obj ect van is Írjon egyko Vonal osztályt, melynek van és Írjunk egy amelynek egy being created ", illetve beállítja a vo na l kiírja, hogy "Objectkonstruktora. is being created," illetve beállítja a vonal paraméteres A konstruktoron ho s szcm-re. át 3 4. 6 cm -re. Az osztályn ak legye n SetLength() e gy hosszát 34.6 legyen egy keresztül adjunk Az átosztálynak egy rövidebb szöveget. A setLen g th() paraméterül füg gv én ye , amely paraméterü l kapértéket és függvénye, amely kap egy hosszkonstruktor feladata legyen az osztály adattagjának érté ket és azt állítja be a vonal azt állítjaeg ybehoasszAz vonal hosszának. egy inicializálása. osztály legyenTovábbá képes alétezzen következő ho s sz án a k. To v á bbá léte zzen egy getL ength() GetLength() függvény, ami visszaadja amagánhangzók, vonal hosszát! A adatokat szolgáltatni: füg gv ény, am i v is sza ad ja a v on a l ho sszát! A az egyvonal adattag típusa double, a láthatósága mássalhangzók és legyen szóközök száma. Az osztály egy vonelvét a l a da ttag t ípu satartva, legyen do uble, a ségbezárás figyelembe private. Dinamikusan függvénye cserélje le a szóközöket #-re. Az egyes l áth at ósá ga a z eg ységbe zárás elvé t figyele m be kezeljük a memóriát, tehát hozzunk létre egy objektumot műveletek végrehajtásához külön függvényeket tartva , pr iva te. Dina mik usa n ke zelj ük a kézzel és egy destruktorral meg. értéke A destrukhasználjon, amelyeknek szüntessük visszatérési a m em ó riát, tehá t hozz unk létre egy obje ktumot tort megvalósító függvény pedig írja ki, hogy „Object feladattól függ. Az osztály függvényeinek ais kéz zel és e gy destruk tor-ral szün tessük me g. A being deleted.” objektumon A vonal hosszát egy konzolos kiíratással meghívását keresztül végezze. Az des tru kto r-t m eg valósító füg g vén y p edig írja szemléltessük. (GYF_CA_06) eredményt egy konzolos kiíratással szemléltesse.

 

ki, hogy „O bjec t is being d ele ted”. A vo na l (CA_02)ho Ez a esor nem fér ki!!!k. ssz át gy konnekem zolo s k iíratássa l szemléltessü Osztálydiagram(Class (Class diagram) Osztálydiagram diagram )

22

21

Katona József−Király Z oltán Osztály és – objektumdiagram (Object diagram)

Osztály és – Objektumdiagram (Object diagram)

class Class Model

length: double

+ + + +

GetLength() : double Line(void) ~Line(void) SetLength(double) : void

LineObj ect:Line -

by set function

by constructor

Line -

LineObj ect:Line

length: double = 34.5

-

 

length: double = 10.4

Book osztályt, amely egy Írjon egyÍrjon Book egy osztályt, amely egy könyvhasználatot könyvha sználatot modellez. A konstruktor modellez. A konstruktor segítségével állítsuk be a maxisegítségével Aállítsuk be függvény a maximális mális oldalszámot. setPage() segítségével oldalszá t. A oldalt setPage() függvény adjuk meg, hogymo hányadik olvassuk. A getPage() segítségével adjuk meg, hogy hányadik függvény segítségével pedig írjuk ki a konzolra az adaoldalt o lvassuk. A getPage() függvény tokat. (GYF_CA_07) Írjunk

egy

olyan

paraméteres keresztül

adjunk

konstruktor

Az

adatokat

használjon, feladattól

meghívását (CA_02)

egy

legyen

osztály

és

A

le

a

szöveget.

adattagjának

osztály

képes

Az

egy

száma.

Az

külön

kiíratással

értéke

végezze.

Osztálydiagram (Class diagram) (Class diagram ) Book currentPage: int numberOfTotalNumberPage: int

+ + + +

Book(int) getPage() : int Print() : void setPage(int) : void

23 Objektumdiagram (Object diagram) class Class Model bookObj ect:Book -

currentPage: int = 23

a

a

Az

szemléltesse.

Ez a sor nekem nem fér ki!!! segítségével pedig írjuk ki a konzolra az

-

egy

egyes

függvényeket

Osztálydiagram class Class Model

22

Az

függvényeinek

keresztül

konzolos

következő

osztály

#-re.

visszatérési

osztály

objektumon

a

A

magánhangzók,

szóközöket

végrehajtásához

függ.

egy

rövidebb

legyen

amelyeknek

van

konstruktoron

az

szóközök

cserélje

műveletek

eredményt

amelynek

szolgáltatni:

mássalhangzók

 

át

feladata

inicializálása.

függvénye

osztályt,

konstruktora.

+ + + +

Book(int) getPage() : int Print() : void setPage(int) : void

Objektumorientált programozás C++ nyelven Objektumdiagram (Object diagram) Objektumdiagram (Object diagram) class Class Model bookObj ect:Book -

Írjunk

egy

currentPage: int = 23 numberOfTotalNumberPage: int = 100

olyan

osztályt,

amelynek

van

egy

Írjon olyan minimum függvényt, amelyek két egész, valós ésÍrjon lebegőpontos változó függvényt, közül kiválasztja, olyan minimum amelyekés annak értékét két adjaegész, vissza! Osztálydiagram diagram ) v(GYF_CA_08) alós és (Class lebegőpontos változó paraméteres keresztül

konstruktora.

adjunk

konstruktor

feladata

inicializálása.

Az

adatokat

legyen

osztály

és

A

konstruktoron

rövidebb

szöveget.

az

adattagjának

osztály

legyen

szóközök

cserélje

műveletek

képes

feladattól

meghívását eredményt

le

a

száma.

szóközöket

amelyeknek

függ.

Az

egy

konzolos

Az

A

következő

osztály

#-re.

külön

Az

értéke

függvényeinek

keresztül

kiíratással

egy

egyes

függvényeket

visszatérési

osztály

objektumon

a

magánhangzók,

végrehajtásához

használjon,

 

egy

szolgáltatni:

mássalhangzók függvénye

át

végezze.

a

a

Az

szemléltesse.

közül kivála sztja, sztja , és annak értékét adja

(CA_02)

Ez

a

sor

nekem

nem

fér

ki!!!

Osztálydiagram (Class diagram) class Class8) Model vissza! (GYF_ CA_0 CA_08) 24 T:class TGetMin + + +

GetMin(T, T) : T TGetMin(void) ~TGetMin(void)

Objektumdiagram (Object diagram)

Objektumdiagram class Class Model(Object diagram) *tGetMinObj ect1:TGetMin -

d

i1: = 20 i2: = 3

*tGetMinObj ect2:TGetMin -

 

f1: = 3.56 f2: = 10.3

*tGetMinObj ect3:TGetMin -

d1: d2:

<double> = -3.5 <double> = 12.6

23

Katona József−Király Z oltán Írjunk

Írjon Írjon olyan olyan osztálysablont, osztálysablont, ahol ahol aa konstruktor konstruktor egy

olyan

osztályt,

amelynek

van

egy

Írjon olyan osztálysablont, ahol paraméterül a konstruktor bármibármily en vár bármily en típusú típusú változót változót paraméterül vár és és lyen típusú változót vár és értékül Az adja értékül adja aazz osztály értékül adjaparaméterül osztály adattagjainak. adattagjainak. Az az osztály adattagjainak. Az osztály adattagjain végezze el osztály végezze elel aa következő osztály adattagjain adattagjain végezze következő a következő műveleteket: szorzás, összeadás. Használjon műveleteket: műveleteket: szorzás, szorzás, összeadás. összeadás. Használjon Használjon adattag-mutatókat! (GYF_CA_09) paraméteres keresztül

konstruktora.

adjunk

konstruktor

feladata

inicializálása.

Az

egy

legyen

osztály

az

adattagjának

szóközök

használjon, feladattól

a

Az

kiíratással

(CA_02)

egy

egyes

értéke

függvényeinek

keresztül

konzolos

Az

függvényeket

visszatérési

osztály

objektumon

egy

következő

osztály

#-re.

külön

adattag mutatókat! adattag mutatókat!(GYF_CA_09) (GYF_CA_09) Ez a sor nekem nem fér

eredményt

a

A

magánhangzók,

szóközöket

amelyeknek Az

képes

száma.

végrehajtásához

függ.

meghívását

le

osztály

legyen

szolgáltatni:

és

cserélje

konstruktoron szöveget.

mássalhangzók műveletek

A

rövidebb

adatokat

függvénye

 

át

végezze.

a

a

Az

szemléltesse.

ki!!!

Osztálydiagram Osztálydiagram(Class (Classdiagram diagram) )

Osztálydiagram (Class diagram) class classClass ClassModel Model T:class T:class TCalc TCalc - - x:x:T*T* - - y:y:T*T* ++ ++ ++ ++ ++

Add() Add(): T :T Multiply() Multiply(): T :T Print() Print(): void : void TCalc(T, TCalc(T,T)T) ~TCalc(void) ~TCalc(void)

Objektumdiagram Objektumdiagram(Object (Objectdiagram) diagram)

Objektumdiagram (Object diagram)

class classClass ClassModel Model

*tCalcObj ect1:TCalc *tCalcObj ect1:TCalc - - i1: i1: = =10 10 - - i2: i2: = =20 20

 

24

*tCalcObj ect2:TCalc *tCalcObj ect2:TCalc - - f1: f1: = =5.66 5.66 - - f2: f2: = =4.83 4.83

26 26

float float

Objektumorientált programozás C++ nyelven

2.

Forráskódok

2. Forráskódok

Muvelet osztály deklarációja (Muvelet.h)

Művelet osztály deklarációja (Muvelet.h)

/******************************************************************   *  Muvelet  osztály  deklarációja                                                                        *   *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  alapértelmezett  konstruktor                                      *   *                                -­‐>  paraméteres  konstruktor                                              *   *                                -­‐>  másoló  konstruktor                                                        *   *                                -­‐>  objektum  paraméter                                                        *   *                                -­‐>  inline  módszer                                                                *   *                                                                                                                                  *   *  Katona  József                                                            *   ******************************************************************* /   #ifndef  MUVELET_H  //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   #define  MUVELET_H  //egy  szimbólum  definiálása  és  értékének  megadása   //=================================================================   class  Muvelet  {   //=================================================================   private:   double  x,  y,  eredmeny;   char  muv;     public:   //alapértelmezett  konstruktor  (inline  módszer)   Muvelet()  {x=1;  y=1;  muv='+';}   //paraméteres  konstruktor   Muvelet(double  x1,  double  y1,  char  muv1);   //másoló  konstruktor   Muvelet(const  Muvelet  &v);   void  Szamol();   void  Kiir();   };   #endif  //feltétel  lezárása  

Muvelet osztály implementálása (Muvelet.cpp)   /******************************************************************   *  Muvelet  osztály  definiálása/implementálása                                            *   *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  alapértelmezett  konstruktor                                      *   *                                -­‐>  paraméteres  konstruktor                                              *   *                                -­‐>  másoló  konstruktor                                                        *   *                                -­‐>  objektum  paraméter                                                        *   *                                -­‐>  inline  módszer                                                                *  

25

//másoló  konstruktor   Muvelet(const  Muvelet  &v);   void  Szamol();   void  Kiir();  

Katona József−Király Z oltán

};   #endif  //feltétel  lezárása  

Művelet osztály implementálása (Muvelet.cpp) Muvelet osztály implementálása (Muvelet.cpp)   /******************************************************************   *  Muvelet  osztály  definiálása/implementálása                                            *   *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  alapértelmezett  konstruktor                                      *   *                                -­‐>  paraméteres  konstruktor                                              *   *                                -­‐>  másoló  konstruktor                                                        *   *                                -­‐>  objektum  paraméter                                                        *   *                                -­‐>  inline  módszer                                                                *  

26

*                                -­‐>  std  névtér                                                                        *   *                                                                                                                                  *   *  Katona  József                                                            *   27 *******************************************************************/   #include                        //C++  alapvető  adatfolyam  I/O  rutinok   #include  "Muvelet.h"                    //a  Muvelet  osztály  deklarációi     using  namespace  std;                    //az  std  névtér  behívása     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   Muvelet  ::  Muvelet(double  x1,  double  y1,  char  muv1)   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   {     this-­‐>x=x1;  this-­‐>y=y1;  this-­‐>muv=muv1;   }     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   Muvelet  ::  Muvelet(const  Muvelet  &v)   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   {     this-­‐>x=v.x;  this-­‐>y=v.y;  this-­‐>muv=v.muv;   }     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   void  Muvelet  ::  Szamol()   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   {     switch(muv)     {                    case  '+':  eredmeny  =  x+y;  break;                    case  '-­‐':  eredmeny  =  x-­‐y;  break;                    case  '*':  eredmeny  =  x*y;  break;                    case  '/':  eredmeny  =  x/y;  break;     }   }     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   void  Muvelet  ::  Kiir()   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   {          cout  <<  x  <<  "  "  <<  muv  <<  "  "  <<  y                    <<  "  =  "  <<  eredmeny  <<  endl;  

  {    //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   switch(muv)    void  Muvelet  ::  Szamol()   {   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐                    case  '+':  eredmeny  =  x+y;  break;   Objektumorientált programozás C++ nyelven {                    case  '-­‐':  eredmeny  =  x-­‐y;  break;     switch(muv)                    case  '*':  eredmeny  =  x*y;  break;     {                    case  '/':  eredmeny  =  x/y;  break;                      case  '+':  eredmeny  =  x+y;  break;   }                    case  '-­‐':  eredmeny  =  x-­‐y;  break;   }                      case  '*':  eredmeny  =  x*y;  break;                    case  '/':  eredmeny  =  x/y;  break;   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐     }   void  Muvelet  ::  Kiir()   }   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐     {   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐          cout  <<  x  <<  "  "  <<  muv  <<  "  "  <<  y   void  Muvelet  ::  Kiir()                    <<  "  =  "  <<  eredmeny  <<  endl;   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   }   {          cout  <<  x  <<  "  "  <<  muv  <<  "  "  <<  y   Muvelet osztály példányosítása (main.cpp)                    <<  "  =  "  <<  eredmeny  <<  endl;   }   /******************************************************************   *  Muvelet  osztály  példányosítása                                                                    *   Muvelet osztály példányosítása (main.cpp)   *  Demonstrációs  célok:                                                                                        *  

Művelet osztály példányosítása (main.cpp)

/******************************************************************   *  Muvelet  osztály  példányosítása                                                                    *   28 *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  különböző  típusú  konstruktorok  hívások                *   *                                -­‐>  strchr()                                                                            *   28 *                                -­‐>  cin  függvény                                                                    *   *                                                                                                                                  *   *  Katona  József                                                            *   *******************************************************************/   #include                        //C++  alapvető  adatfolyam  I/O  rutinok   #include                          //C++  verziója,  C  "string.h"-­‐nak   #include                          //DOS  konzol  I/O  rutinok  hívása   #include  "Muvelet.h"                    //a  Muvelet  osztály  deklarációi     using  namespace  std;                    //az  std  névtér  behívása     //*****************************************************************   int  main()   //*****************************************************************   {          double  a1,  b1;          char  m;          Muvelet  w1;                                    //alapértelmezett  konstruktor  hívása          w1.Szamol();          w1.Kiir();          cout  <<  "1.adat:  ";  cin  >>  a1;          cout  <<  "2.adat:  ";  cin  >>  b1;            do          {                  cout  <<  "muveleti  jel  (+,-­‐,*,/):  ";  cin  >>  m;          }  while(!strchr("+-­‐*/",m));              Muvelet  w2(a1,  b1,  m);              //a  paraméteres  konstruktor  hívása          w2.Szamol();  

27

{          Muvelet  w1;                                    //alapértelmezett  konstruktor  hívása          double  a1,  b1;          w1.Szamol();          char  m;          w1.Kiir();          Muvelet  w1;                                    //alapértelmezett  konstruktor  hívása          cout  <<  "1.adat:  ";  cin  >>  a1;   Katona József−Király Z oltán        w1.Szamol();          cout  <<  "2.adat:  ";  cin  >>  b1;          w1.Kiir();            cout  <<  "1.adat:  ";  cin  >>  a1;          do          cout  <<  "2.adat:  ";  cin  >>  b1;            {                  cout  <<  "muveleti  jel  (+,-­‐,*,/):  ";  cin  >>  m;          do          }  while(!strchr("+-­‐*/",m));            {                    cout  <<  "muveleti  jel  (+,-­‐,*,/):  ";  cin  >>  m;          Muvelet  w2(a1,  b1,  m);              //a  paraméteres  konstruktor  hívása          }  while(!strchr("+-­‐*/",m));              w2.Szamol();          w2.Kiir();          Muvelet  w2(a1,  b1,  m);              //a  paraméteres  konstruktor  hívása          Muvelet  w3(w2);                            //a  másoló  konstruktor  hívása          w2.Szamol();          w3.Szamol();          w2.Kiir();          w3.Kiir();          Muvelet  w3(w2);                            //a  másoló  konstruktor  hívása            w3.Szamol();          getch();          w3.Kiir();            return  0;   }          getch();          return  0;   }  Rectangle osztály deklarációja (Rectangle.h)

Rectangle osztály deklarációja (Rectangle.h)

Rectangle osztály deklarációja (Rectangle.h) /******************************************************************   *  Rectangle  osztály  deklarációja                                                                    *   *  Demonstrációs  célok:                                                                                        *   /******************************************************************   *                                -­‐>  adattag  mutatók                                                              *   *  Rectangle  osztály  deklarációja                                                                    *   *                                -­‐>  dinamikus  memória  kezelés  OOP-­‐ben                          *   *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  destruktor                                                                        *   *                                -­‐>  adattag  mutatók                                                              *   *                                -­‐>  dinamikus  memória  kezelés  OOP-­‐ben                          *   *                                -­‐>  destruktor                                                                        *  

29

28

*                                -­‐>  inline  módszer                                                                *   *                                                                                                                                  *   29 *  Katona  József                                                            *   *******************************************************************/   #ifndef  RECTANGLE_H  //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   #define  RECTANGLE_H  //egy  szimbólum  definiálása  és  értékének  megadása   //=================================================================   #include                        //C++  alapvető  adatfolyam  I/O  rutinok     using  namespace  std;                    //az  std  névtér  behívása     //=================================================================   class  Rectangle  {   //=================================================================   private:     double  *a,  *b;     public:       Rectangle(double  magassag,  double  szelesseg)     {       //dinamikus  helyfoglalás       //az  adattag-­‐mutatók  számára       this-­‐>a  =  new  double(magassag);           this-­‐>b  =  new  double(szelesseg);     }  

//=================================================================   private:     double  *a,  *b;     Objektumorientált programozás C++ nyelven public:       Rectangle(double  magassag,  double  szelesseg)     {       //dinamikus  helyfoglalás       //az  adattag-­‐mutatók  számára       this-­‐>a  =  new  double(magassag);           this-­‐>b  =  new  double(szelesseg);     }       double  Area()     {       return  2*(*a+*b);     }       double  District()     {       return  *a**b;     }       void  Printer()     {       cout  <<  "A  TEGLALAP  ADATAI:  "  <<  endl;       cout  <<  "==================  "  <<  endl;       cout  <<  "a  oldal  =  "  <<  *a  <<  "  cm"  <<  endl;       cout  <<  "b  oldal  =  "  <<  *b  <<  "  cm"  <<  endl;       printf("Kerulet:  %.2lf  cm",  this-­‐>Area());       cout  <<  endl;       printf("Terulet:  %.2lf  cm^2",  this-­‐>District());     }       ~Rectangle()     {       delete  a;    //adattagmutató  törlése  a  memóriából       delete  b;    //adattagmutató  törlése  a  memóriából   30   }   };   #endif  //feltétel  lezárása  

Rectangle osztály példányosítása (main.cpp) /******************************************************************   *  Rectangle  osztály  példányosítása                                                                *   *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  dinamikus  helyfoglalású  objketumpéldány              *   *                                -­‐>  "-­‐>"  operátor                                                                *   *                                                                                                                                  *   *  Katona  József                                                            *   *******************************************************************/   #include                        //C++  alapvető  adatfolyam  I/O  rutinok   #include                          //DOS  konzol  I/O  rutinok  hívása   #include  "Rectangle.h"                //a  Rectangle  osztály  deklarációi     //*****************************************************************   int  main()  

29

    delete  a;    //adattagmutató  törlése  a  memóriából       delete  b;    //adattagmutató  törlése  a  memóriából     delete  a;    //adattagmutató  törlése  a  memóriából       }   József−Király Z oltán     Katona delete  b;    //adattagmutató  törlése  a  memóriából   };     }   #endif  //feltétel  lezárása   };   #endif  //feltétel  lezárása  

Rectangle osztály példányosítása Rectangle osztály példányosítása (main.cpp)

(main.cpp)

Rectangle osztály példányosítása (main.cpp)

/******************************************************************   *  Rectangle  osztály  példányosítása                                                                *   /******************************************************************   *  Demonstrációs  célok:                                                                                        *   *  Rectangle  osztály  példányosítása                                                                *   *                                -­‐>  dinamikus  helyfoglalású  objketumpéldány              *   *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  "-­‐>"  operátor                                                                *   *                                -­‐>  dinamikus  helyfoglalású  objketumpéldány              *   *                                                                                                                                  *   *                                -­‐>  "-­‐>"  operátor                                                                *   *  Katona  József                                                            *   *                                                                                                                                  *   *******************************************************************/   *  Katona  József                                                            *   #include                        //C++  alapvető  adatfolyam  I/O  rutinok   *******************************************************************/   #include                          //DOS  konzol  I/O  rutinok  hívása   #include                        //C++  alapvető  adatfolyam  I/O  rutinok   #include  "Rectangle.h"                //a  Rectangle  osztály  deklarációi    #include                          //DOS  konzol  I/O  rutinok  hívása   #include  "Rectangle.h"                //a  Rectangle  osztály  deklarációi   //*****************************************************************     int  main()   //*****************************************************************   //*****************************************************************   int  main()   {      //*****************************************************************   //dinamikus  helyfoglalású  objektumpéldány      {   Rectangle  *RectangleObject  =  new  Rectangle(10.2,  21.5);   //dinamikus  helyfoglalású  objektumpéldány       RectangleObject-­‐>Area();   Rectangle  *RectangleObject  =  new  Rectangle(10.2,  21.5);       RectangleObject-­‐>District();   RectangleObject-­‐>Area();       RectangleObject-­‐>Printer();   RectangleObject-­‐>District();       //objektumpéldány  meszüntetése   RectangleObject-­‐>Printer();       delete  RectangleObject;             //objektumpéldány  meszüntetése       delete  RectangleObject;                 getch();       return  0;     getch();   }   return  0;       }    

Swap osztály deklarációja (Swap.h)

Swap osztály deklarációja Swap osztály deklarációja (Swap.h)

(Swap.h)

/******************************************************************   *  Swap  osztály  deklarációja                                                                              *   /******************************************************************   *  Demonstrációs  célok:                                                                                        *   *  Swap  osztály  deklarációja                                                                              *   *                                -­‐>  memóriacím  szerinti  paraméterátadadás                  *   *  Demonstrációs  célok:                                                                                        *   *                                                                                                                                  *   *                                -­‐>  memóriacím  szerinti  paraméterátadadás                  *   *  Katona  József                                                            *   *                                                                                                                                  *   *******************************************************************/   *  Katona  József                                                            *   #ifndef  SWAP_H  //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   *******************************************************************/   #define  SWAP_H  //egy  szimbólum  definiálása  és  értékének  megadása   #ifndef  SWAP_H  //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   #define  SWAP_H  //egy  szimbólum  definiálása  és  értékének  megadása  

Swap osztály implementálása (Swap.cpp) Swap osztály példányosítása (main.cpp) 31 31

30

Objektumorientált programozás C++ nyelven //=================================================================   class  Swap  {   //=================================================================   //=================================================================     public:   class  Swap  {       Swap(void);   //=================================================================         public:   //függvény  értékátadás  cím  szerint       void  IntegerSwapper(int&  v1,  int&  v2);       Swap(void);       void  FloatSwapper(float&  v1,  float&  v2);       //függvény  értékátadás  cím  szerint       void  CharSwapper(char&  v1,  char&  v2);       void  IntegerSwapper(int&  v1,  int&  v2);       ~Swap(void);       void  FloatSwapper(float&  v1,  float&  v2);   };       void  CharSwapper(char&  v1,  char&  v2);   #endif  //feltétel  lezárása       ~Swap(void);   };   #endif  //feltétel  lezárása   Swap osztály implementálása (Swap.cpp)  

Swap osztály implementálása (Swap.cpp)

Swap osztály implementálása (Swap.cpp)   /******************************************************************   *  Swap  osztály  definiálása/implementálása                                                  *   *  Demonstrációs  célok:                                                                                        *   /******************************************************************   *                                -­‐>  különböző  típusú  adatok  cseréje                              *   *  Swap  osztály  definiálása/implementálása                                                  *   *                                                                                                                                  *   *  Demonstrációs  célok:                                                                                        *   *  Katona  József                                                            *   *                                -­‐>  különböző  típusú  adatok  cseréje                              *   *******************************************************************/   *                                                                                                                                  *   #include  "Swap.h"                                                //Swap  osztály  deklarációi   *  Katona  József                                                            *     *******************************************************************/   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   #include  "Swap.h"                                                //Swap  osztály  deklarációi   Swap::Swap(void)  {}     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐     Swap::Swap(void)  {}   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   void  Swap::IntegerSwapper(int&  v1,  int&  v2)     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   {   void  Swap::IntegerSwapper(int&  v1,  int&  v2)     int  temp;   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐     temp  =  v1;   {     v1  =  v2;     int  temp;     v2  =  temp;     temp  =  v1;   }     v1  =  v2;       v2  =  temp;   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   }   void  Swap::FloatSwapper(float&  v1,  float&  v2)     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   {   void  Swap::FloatSwapper(float&  v1,  float&  v2)     float  temp;   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐     temp  =  v1;   {     v1  =  v2;     float  temp;     v2  =  temp;     temp  =  v1;   }     v1  =  v2;       v2  =  temp;   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   }     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   32

31

  //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   void  Swap::FloatSwapper(float&  v1,  float&  v2)   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   Katona József−Király Z oltán {     float  temp;     temp  =  v1;     v1  =  v2;     v2  =  temp;   }     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   void  Swap::CharSwapper(char&  v1,  char&  v2)   void  Swap::CharSwapper(char&  v1,  char&  v2)   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   32 {   {     char  temp;     char  temp;     temp  =  v1;     temp  =  v1;     v1  =  v2;     v1  =  v2;     v2  =  temp;     v2  =  temp;   }   }       //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   Swap::~Swap(void)  {}   Swap::~Swap(void)  {}   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐      

Swap példányosítása (main.cpp)   Swap osztály osztály példányosítása (main.cpp)   Swap osztály példányosítása

32

(main.cpp)

/******************************************************************   /******************************************************************   *  Swap  osztály  példányosítása                                                                          *   *  Swap  osztály  példányosítása                                                                          *   *  Demonstrációs  célok:                                                                                        *   *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  Swap  osztály  példányosítása                                      *   *                                -­‐>  Swap  osztály  példányosítása                                      *   *                                                                                                                                  *   *                                                                                                                                  *   *  Katona  József                                                            *   *  Katona  József                                                            *   *******************************************************************/   *******************************************************************/   #include                        //C++  alapvető  adatfolyam  I/O  rutinok   #include                        //C++  alapvető  adatfolyam  I/O  rutinok   #include                          //DOS  konzol  I/O  rutinok  hívása   #include                          //DOS  konzol  I/O  rutinok  hívása   #include  "Swap.h"                          //a  Swap  osztály  deklarációi   #include  "Swap.h"                          //a  Swap  osztály  deklarációi       using  namespace  std;                    //az  std  névtér  behívása   using  namespace  std;                    //az  std  névtér  behívása       //*****************************************************************   //*****************************************************************   int  main()   int  main()   //*****************************************************************   //*****************************************************************   {   {     int      i1=10,    i2=-­‐4;     int      i1=10,    i2=-­‐4;     float  f1=1.5,  f2=2.8;     float  f1=1.5,  f2=2.8;     char    c1='*',  c2='#';     char    c1='*',  c2='#';         Swap  *objectOfSwap  =  new  Swap();     Swap  *objectOfSwap  =  new  Swap();     cout  <<  "csere  elott    i1  :  "  <<  i1  <<  "  i2  :  "  <<  i2  <<  endl;     cout  <<  "csere  elott    i1  :  "  <<  i1  <<  "  i2  :  "  <<  i2  <<  endl;     objectOfSwap-­‐>IntegerSwapper(i1,  i2);     objectOfSwap-­‐>IntegerSwapper(i1,  i2);     cout  <<  "csere  utan      i1  :  "  <<  i1  <<  "  i2  :  "  <<  i2  <<  endl;     cout  <<  "csere  utan      i1  :  "  <<  i1  <<  "  i2  :  "  <<  i2  <<  endl;     cout  <<  "csere  elott    f1  :  "  <<  f1  <<  "  f2  :  "  <<  f2  <<  endl;     cout  <<  "csere  elott    f1  :  "  <<  f1  <<  "  f2  :  "  <<  f2  <<  endl;     objectOfSwap-­‐>FloatSwapper(f1,  f2);     objectOfSwap-­‐>FloatSwapper(f1,  f2);     cout  <<  "csere  utan      f1  :  "  <<  f1  <<  "  f2  :  "  <<  f2  <<  endl;     cout  <<  "csere  utan      f1  :  "  <<  f1  <<  "  f2  :  "  <<  f2  <<  endl;     cout  <<  "csere  elott    c1  :  "  <<  c1  <<  "  c2  :  "  <<  c2  <<  endl;     cout  <<  "csere  elott    c1  :  "  <<  c1  <<  "  c2  :  "  <<  c2  <<  endl;     objectOfSwap-­‐>CharSwapper(c1,  c2);     objectOfSwap-­‐>CharSwapper(c1,  c2);     cout  <<  "csere  utan      c1  :  "  <<  c1  <<  "  c2  :  "  <<  c2  <<  endl;  

int  main()   //*****************************************************************   {     int      i1=10,    i2=-­‐4;   programozás C++ nyelven Objektumorientált   float  f1=1.5,  f2=2.8;     char    c1='*',  c2='#';       Swap  *objectOfSwap  =  new  Swap();     cout  <<  "csere  elott    i1  :  "  <<  i1  <<  "  i2  :  "  <<  i2  <<  endl;     objectOfSwap-­‐>IntegerSwapper(i1,  i2);     cout  <<  "csere  utan      i1  :  "  <<  i1  <<  "  i2  :  "  <<  i2  <<  endl;     cout  <<  "csere  elott    f1  :  "  <<  f1  <<  "  f2  :  "  <<  f2  <<  endl;     objectOfSwap-­‐>FloatSwapper(f1,  f2);     cout  <<  "csere  utan      f1  :  "  <<  f1  <<  "  f2  :  "  <<  f2  <<  endl;     cout  <<  "csere  elott    c1  :  "  <<  c1  <<  "  c2  :  "  <<  c2  <<  endl;     objectOfSwap-­‐>CharSwapper(c1,  c2);     cout  <<  "csere  utan      c1  :  "  <<  c1  <<  "  c2  :  "  <<  c2  <<  endl;   delete  objectOfSwap;     _getch();       _getch();   return  0;     return  0;   }    }    

33 OSwap osztály deklarációja (OSwap.h) OSwap osztály deklarációja OSwap osztály deklarációja (OSwap.h)

(OSwap.h)

/********************************************************************   /********************************************************************   *  OSwap  osztály  deklarációja                                                                                *   *  OSwap  osztály  deklarációja                                                                                *   *  Demonstrációs  célok:                                                                                            *   *  Demonstrációs  célok:                                                                                            *   *                                -­‐>  függvények  túlterhelése/felüldefiniálása                *   *                                -­‐>  függvények  túlterhelése/felüldefiniálása                *   *                                                                                                                                      *   *                                                                                                                                      *   *  Katona  József                                                                *   *  Katona  József                                                                *   ********************************************************************/   ********************************************************************/   #ifndef  OSWAP_H          //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   #ifndef  OSWAP_H          //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   #define  OSWAP_H          //egy  szimbólum  definiálása  és  értékének  megadása   #define  OSWAP_H          //egy  szimbólum  definiálása  és  értékének  megadása   //===================================================================   //===================================================================   class  OSwap  {   class  OSwap  {   //===================================================================   //===================================================================   public:    public:  OSwap(void);   OSwap(void);       void  Swapper(int&  v1,  int&  v2);   void  Swapper(int&  v1,  int&  v2);       void  Swapper(float&  v1,  float&  v2);   void  Swapper(float&  v1,  float&  v2);       void  Swapper(char&  v1,  char&  v2);   void  Swapper(char&  v1,  char&  v2);       ~OSwap(void);     ~OSwap(void);   };   };   #endif  //feltétel  lezárása    #endif  //feltétel  lezárása    

OSwap osztály implementálása (OSwap.cpp)   OSwap osztály implementálása (OSwap.cpp)   /******************************************************************   /******************************************************************   *  OSwap  osztály  definiálása/implementálása                                                *   *  OSwap  osztály  definiálása/implementálása                                                *   *  Demonstrációs  célok:                                                                                        *   *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  túlterhelt  függvények  kifejtése                              *   *                                -­‐>  túlterhelt  függvények  kifejtése                              *   *                                                                                                                                  *   *                                                                                                                                  *   *  Katona  József                                                            *   *  Katona  József                                                            *   *******************************************************************/   *******************************************************************/   #include  "OSwap.h"                                            //OSwap  osztály  deklarációi    #include  "OSwap.h"                                            //OSwap  osztály  deklarációi     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   OSwap::OSwap(void)  {}  

33

  void  Swapper(char&  v1,  char&  v2);     ~OSwap(void);   };   #endif  //feltétel  lezárása   Katona József−Király Z oltán  

OSwap osztály implementálása (OSwap.cpp)  

OSwap osztály implementálása OSwap.cpp)

/******************************************************************   *  OSwap  osztály  definiálása/implementálása                                                *   *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  túlterhelt  függvények  kifejtése                              *   *                                                                                                                                  *   *  Katona  József                                                            *   *******************************************************************/   #include  "OSwap.h"                                            //OSwap  osztály  deklarációi     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   OSwap::OSwap(void)  {}   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   void  OSwap::Swapper(int&  v1,  int&  v2)   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   {     int  temp;     temp  =  v1;   34   v1  =  v2;     v2  =  temp;   }     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   void  OSwap::Swapper(float&  v1,  float&  v2)   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   {     float  temp;     temp  =  v1;     v1  =  v2;     v2  =  temp;   }   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   void  OSwap::Swapper(char&  v1,  char&  v2)   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   {     char  temp;     temp  =  v1;     v1  =  v2;     v2  =  temp;   }     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   OSwap::~OSwap(void)  {}   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐  

34

OSwap osztály példányosítása (main.cpp)   /********************************************************************   *  OSwap  osztály  példányosítása                                                                            *  

}     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   OSwap::~OSwap(void)  {}   Objektumorientált programozás C++ nyelven //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐  

OSwap osztály példányosítása (main.cpp)   OSwap osztály példányosítása

(main.cpp)

/********************************************************************   *  OSwap  osztály  példányosítása                                                                            *   *  Demonstrációs  célok:                                                                                            *   *                                -­‐>  túlterhelt  függvények  hívásai                                      *   *                                                                                                                                      *   *  Katona  József                                                                *   ********************************************************************/   #include                            //C++  alapvető  adatfolyam  I/O  rutinok   #include                              //DOS  konzol  I/O  rutinok  hívása   #include  "OSwap.h"                            //az  OSwap  osztály  deklarációi     using  namespace  std;                        //az  std  névtér  behívása     //*******************************************************************   int  main()   //*******************************************************************   {     int      i1  =  10,    i2  =  -­‐4;     float  f1  =  1.5,  f2  =  2.8;     char    c1  =  '*',  c2  =  '#';     35   OSwap  *swapperObject  =  new  OSwap();     cout  <<  "csere  elott    i1  :  "  <<  i1  <<  "  i2  :  "  <<  i2  <<  endl;     swapperObject-­‐>Swapper(i1,  i2);     cout  <<  "csere  utan      i1  :  "  <<  i1  <<  "  i2  :  "  <<  i2  <<  endl;     cout  <<  "csere  elott    f1  :  "  <<  f1  <<  "  f2  :  "  <<  f2  <<  endl;     swapperObject-­‐>Swapper(f1,  f2);     cout  <<  "csere  utan      f1  :  "  <<  f1  <<  "  f2  :  "  <<  f2  <<  endl;     cout  <<  "csere  elott    c1  :  "  <<  c1  <<  "  c2  :  "  <<  c2  <<  endl;     swapperObject-­‐>Swapper(c1,  c2);     cout  <<  "csere  utan      c1  :  "  <<  c1  <<  "  c2  :  "  <<  c2  <<  endl;     delete  swapperObject;       _getch();     return  0;   }  

TSwap osztály deklarációja (TSwap.h) /********************************************************************   *  TSwap  osztály  deklarációja                                                                                *   *  Demonstrációs  célok:                                                                                            *   *                                -­‐>  függvénysablonok                                                                *   *                                -­‐>  template  kulcsszó                                                              *       *                                                                                                                                      *   *  Katona  József                                                                *   ********************************************************************/   #ifndef  TSWAP_H          //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   #define  TSWAP_H          //egy  szimbólum  definiálása  és  értékének  megadása   //===================================================================   template    class  TSwap  {  

35

              }   }  

delete  swapperObject;   _getch();   _getch();   return  0;   return  0;  

Katona József−Király Z oltán

TSwap osztály deklarációja (TSwap.h) TSwap osztály deklarációja (TSwap.h)

TSwap osztály deklarációja (TSwap.h)

/********************************************************************   /********************************************************************   *  TSwap  osztály  deklarációja                                                                                *   *  TSwap  osztály  deklarációja                                                                                *   *  Demonstrációs  célok:                                                                                            *   *  Demonstrációs  célok:                                                                                            *   *                                -­‐>  függvénysablonok                                                                *   *                                -­‐>  függvénysablonok                                                                *   *                                -­‐>  template  kulcsszó                                                              *       *                                -­‐>  template  kulcsszó                                                              *       *                                                                                                                                      *   *                                                                                                                                      *   *  Katona  József                                                                *   *  Katona  József                                                                *   ********************************************************************/   ********************************************************************/   #ifndef  TSWAP_H          //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   #ifndef  TSWAP_H          //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   #define  TSWAP_H          //egy  szimbólum  definiálása  és  értékének  megadása   #define  TSWAP_H          //egy  szimbólum  definiálása  és  értékének  megadása   //===================================================================   //===================================================================   template    class  TSwap  {   template    class  TSwap  {   //===================================================================   //===================================================================     public:     public:       TSwap(void);       TSwap(void);       void  swapper(T&  v1,  T&  v2);       void  swapper(T&  v1,  T&  v2);       ~TSwap(void);       ~TSwap(void);   };   };   #endif  //feltétel  lezárása   #endif  //feltétel  lezárása  

TSwap osztály implementálása (TSwap.cpp)   TSwap osztály implementálása (TSwap.cpp)   TSwap osztály implementálása

36

(TSwap.cpp)

/******************************************************************   /******************************************************************   *  TSwap  osztály  definiálása/implementálása                                                *   *  TSwap  osztály  definiálása/implementálása                                                *   *  Demonstrációs  célok:                                                                                        *   *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  függvénysablonok  kifejtése                                        *   *                                -­‐>  függvénysablonok  kifejtése                                        *   *                                                                                                                                  *   *                                                                                                                                  *   *  Katona  József                                                            *   *******************************************************************/   #include  "TSwap.h"                                              //TSwap  osztály  deklaráció   36   36 //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   template    TSwap  ::  TSwap(void)  {}   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   template    void  TSwap  ::swapper(T&  v1,  T&  v2)   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   {     T  temp;     temp    =  v1;     v1  =  v2;     v2  =  temp;   }     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   template    TSwap  ::  ~TSwap(void)  {}   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐  

TSwap osztály példányosítása (main.cpp)  

}     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   template    TSwap  ::  ~TSwap(void)  {}   Objektumorientált programozás C++ nyelven //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐  

TSwap osztály példányosítása (main.cpp)  

TSwap osztály példányosítása (main.cpp)

/******************************************************************   *  TSwap  osztály  példányosítása                                                                        *   *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  függvénysablonok  hívása  különböző  típusokkal    *   *                                                                                                                                  *   *  Katona  József                                                            *   *******************************************************************/   #include                        //C++  alapvető  adatfolyam  I/O  rutinok   #include                          //DOS  konzol  I/O  rutinok  hívása   #include  "TSwap.cpp"                    //a  TSwap  osztály  deklarációi     using  namespace  std;                    //az  std  névtér  behívása     //*****************************************************************   int  main()   //*****************************************************************   {     int      i1  =  10,    i2  =  -­‐4;     float  f1  =  1.5,  f2  =  2.8;     char    c1  =  '*',  c2  =  '#';       TSwap  *p1  =  new  TSwap();     cout  <<  "csere  elott    i1  :  "  <<  i1  <<  "  i2  :  "  <<  i2  <<  endl;     p1-­‐>swapper(i1,  i2);  //függvénysablon  hívása  integer  típussal     cout  <<  "csere  utan      i1  :  "  <<  i1  <<  "  i2  :  "  <<  i2  <<  endl;     delete  p1;         TSwap  *p2  =  new  TSwap();   37   cout  <<  "csere  elott    f1  :  "  <<  f1  <<  "  f2  :  "  <<  f2  <<  endl;     p2-­‐>swapper(f1,  f2);  //függvénysablon  hívása  float  típussal     cout  <<  "csere  utan      f1  :  "  <<  f1  <<  "  f2  :  "  <<  f2  <<  endl;     delete  p2;       TSwap  *p3  =  new  TSwap();     cout  <<  "csere  elott    c1  :  "  <<  c1  <<  "  c2  :  "  <<  c2  <<  endl;     p3-­‐>swapper(c1,  c2);  //függvénysablon  hívása  char  típussal     cout  <<  "csere  utan      c1  :  "  <<  c1  <<  "  c2  :  "  <<  c2  <<  endl;     delete  p3;       _getch();     return  0;   }    

TGetMax osztály deklarációja (TGetMax.h) /********************************************************************   *  TGetMax  osztály  deklarációja                                                                            *   *  Demonstrációs  célok:                                                                                            *   *                                -­‐>  osztálysablon  deklaráció                                                *   *                                                                                                                                      *  

37

            }   }      

_getch();   _getch();   return  0;   return  0;  

Katona József−Király Z oltán

TGetMax TGetMax osztály osztály deklarációja deklarációja (TGetMax.h) (TGetMax.h)

TGetMax osztály deklarációja (TGetMax.h)

/********************************************************************   /********************************************************************   *  TGetMax  osztály  deklarációja                                                                            *   *  TGetMax  osztály  deklarációja                                                                            *   *  Demonstrációs  célok:                                                                                            *   *  Demonstrációs  célok:                                                                                            *   *                                -­‐>  osztálysablon  deklaráció                                                *   *                                -­‐>  osztálysablon  deklaráció                                                *   *                                                                                                                                      *   *                                                                                                                                      *   *  Katona  József                                                                *   *  Katona  József                                                                *   ********************************************************************* ********************************************************************* /   /   #ifndef  TGETMAX_H  //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   #ifndef  TGETMAX_H  //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   #define  TGETMAX_H  //egy  szimbólum  definiálása  és  értékének  megadása   #define  TGETMAX_H  //egy  szimbólum  definiálása  és  értékének  megadása   //===================================================================   //===================================================================   template    class  TGetMax  {   template    class  TGetMax  {   //===================================================================   //===================================================================                  T  a,  b;          //alapértelmezett  láthatóságú  T  típusú  adattag                  T  a,  b;          //alapértelmezett  láthatóságú  T  típusú  adattag                public:            public:                  TGetMax(T  first,  T  second);                  TGetMax(T  first,  T  second);                  T  GetMax();                  T  GetMax();                ~TGetMax(void);                ~TGetMax(void);   };   };   #endif  //feltétel  lezárása   #endif  //feltétel  lezárása      

TGetMax osztály implementálása (TGetMax.cpp)   TGetMax osztály implementálása (TGetMax.cpp) TGetMax osztály implementálása (TGetMax.cpp)  

38

/******************************************************************   /******************************************************************   *  TGetMax  osztály  definiálása/implementálása                                            *   *  TGetMax  osztály  definiálása/implementálása                                            *   *  Demonstrációs  célok:                                                                                        *   *                                -­‐>  függvénysablonok  kifejtése                                        *   *                                                                                                                                  *   38 38 *  Katona  József                                                            *   *******************************************************************/   #include  "TSwap.h"                                              //TSwap  osztály  deklaráció     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   template    TSwap  ::  TSwap(void)  {}   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   template    void  TSwap  ::swapper(T&  v1,  T&  v2)   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   {     T  temp;     temp    =  v1;     v1  =  v2;     v2  =  temp;   }     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   template    TSwap  ::  ~TSwap(void)  {}   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐  

  template    TSwap  ::  TSwap(void)  {}   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   template    void  TSwap  ::swapper(T&  v1,  T&  v2)     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   Objektumorientált programozás C++ nyelven {   template    void  TSwap  ::swapper(T&  v1,  T&  v2)     T  temp;   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐     temp    =  v1;   {   v1  =  v2;     T  temp;   v2  =  temp;     temp    =  v1;   }     v1  =  v2;     v2  =  temp;   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   }   template    TSwap  ::  ~TSwap(void)  {}     //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐   template    TSwap  ::  ~TSwap(void)  {}   //-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐-­‐  

TGetMax osztály példányosítása (main.cpp)  

TGetMax osztály példányosítása (main.cpp)   TGetMax osztály példányosítása

(main.cpp)

/********************************************************************   *  TGetMax  osztály  deklarációja                                                                            *   *  Demonstrációs  célok:                                                                                            *   /********************************************************************   *                                -­‐>  osztálysablon  deklaráció                                                *   *  TGetMax  osztály  deklarációja                                                                            *   *                                                                                                                                      *   *  Demonstrációs  célok:                                                                                            *   *  Katona  József                                                                *   *                                -­‐>  osztálysablon  deklaráció                                                *   ********************************************************************* *                                                                                                                                      *   /   *  Katona  József                                                                *   #ifndef  TGETMAX_H  //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   ********************************************************************* #define  TGETMAX_H  //egy  szimbólum  definiálása  és  értékének  megadása   /   //===================================================================   #ifndef  TGETMAX_H  //if  not  define  egy  szimbólum  nemlétét  ellenőrzi   template    class  TGetMax  {   #define  TGETMAX_H  //egy  szimbólum  definiálása  és  értékének  megadása   //===================================================================                  T  a,  b;                //alapértelmezett  láthatóságú  T  típusú  adattag   template    class  TGetMax  {     //===================================================================            public:                  T  a,  b;                //alapértelmezett  láthatóságú  T  típusú  adattag                  TGetMax(T  first,  T  second);                    T  GetMax();            public:                ~TGetMax(void);                  TGetMax(T  first,  T  second);   };                  T  GetMax();   #endif  //feltétel  lezárása                ~TGetMax(void);   };   #endif  //feltétel  lezárása  

39 39

39

Katona József−Király Z oltán

3. Felhasznált irodalom Andrei Alexandrescu−Herb Sutter(2005): C++ kódolási szabályok. Kiskapu kiadó. Robert A. Maksimchuck−Eric J. Naiburg (2006): UML földi halandóknak. Kiskapu kiadó. Alex Allain (2013): Jumping Into C++. Cprogramming.com kiadó. Mike McGrath(2011): C++ Programming In Easy Steps 4th Edition. In Easy Steps Limited kiadó. Bjarne Stroustrup (2013): The C++ Programming Language. Addison Wesley kiadó Nicolai M. Josuttis (2012): The C++ Standard Library: A Tutorial and Reference. Addison Wesley kiadó. Ivor Horton (2014): Ivor Horton's Beginning Visual C++ 2013 (Wrox Beginning Guides). John Wiley & Sons kiadó. David Vandevoorde (2014): C++ Templates: The Complete Guide. Addison Wesley kiadó. Marc Gregoire (2014): Professional C++. John Wiley & Sons kiadó. Martin Fowler(2003): UML Distilled: A Brief Guide to the Standard Object Modeling Language (Object Technology Series). Addison Wesley kiadó. Craig Larman(2004): Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development. Prentice Hall kiadó. Simon Bennet−Steve Mcrobb−Ray Farmer (2006): Object-Oriented Systems Analysis and Design Using UML. McGraw-Hill Higher Education kiadó. David P. Tegarden−Alan Dennis−Barbara Haley Wixom (2012): Systems Analysis and Design with UML. John Wiley & Sons kiadó. Segédanyagok Továbbá számos olyan nagyobb magyar és külföldi egyetemektől származó publikáció, könyv és segédlet került felhasználásra, amelyek külön nem kaptak helyet a felsorolásban.

40