ProgII 02

Programozás II.
Dr. Siket István
Szegedi Tudományegyetem
Informatikai Intézet
Szoftverfejlesztés Tanszék
2023
Programozás II. 1 / 82
Tartalom
Bevezetés C++ string

1 Bevezetés
Kurzus információk
3 Ismétlés, eltérések 4 Objektum-orientált C++
Bevezető Bevezető
2 C++ Nyelv I/O műveletek Konstruktor, destruktor
Programozás II. Bevezetés 2 / 82

Tartalom

1 Bevezetés
Bevezető Bevezető
Programozás II. Bevezetés Kurzus információk 3 / 82

Előadó
Dr. Siket István
szoba: Szoftverfejlesztés Tanszék (Árpád tér 2.)
földszint 17. szoba
telefon: +36 62 54-4158
e-mail: siket@inf.u-szeged.hu
honlap: http://www.inf.u-szeged.hu/~siket/

Előfeltételek, jelentkezés
Előfeltételek
Programozás alapjai
C programozási nyelv
Programozás I. (gyakorlat)
Objektum-orientált programozás
Aki nem teljesítette ezeket a tárgyakat, NE vegye fel a kurzust!
Kurzusra jelentkezés
A kurzusra a Neptunon keresztül lehet jelentkezni
Kurzusfelvevő lap
Csak olyan gyakorlatra lehet jelentkezni, ahol van hely

Gyakorlat anyaga, részvétel
Nappali
Minden gyakorlaton pont ugyanaz az anyag lesz

Az adott heti feladat megoldását felrakjuk
Az előző hetit folytatjuk
A gyakorlat látogatása kötelező
Első két hét kivétel
Két igazolatlan hiányzás lehet
Nem eshet ZH időpontra (a ZH ilyen esetben nem pótolható)
Kettőnél több igazolatlan hiányzás esetén a félév nem teljesített
Igazolt hiányzás
Előre is lehet jelezni
Igazolást be kell mutatni
ZH-t be lehet pótolni

Gyakorlat számonkérés
Nappali
Kvíz (CooSpace kérdések)

Gyakorlat elején 2 kérdés (3 perc)
Egy az előző heti előadásból, egy ismétlő kérdés
17 pontot lehet szerezni
A 2. héten 1 kérdés lesz
Rossz válaszért lesz pontlevonás
Legalább 50%-ot el kell érni
Heti házi feladat
Bírón kell beadni kedd délig
9 pontot lehet szerezni
Legalább 1 pontot el kell érni
3 ZH a félév során
Gép előtt, bíró értékeli
Általunk biztosított segédanyag használható
121 pontot lehet szerezni (28, 54, 39)
Legalább 63 pontot el kell érni

Gyakorlati jegy
Nappali
Elégséges jegyhez követelmény

Maximum 2 igazolatlan hiányzás
Házifeladatokból minimum 1 pont (9 pontból)
Kvízből minimum 50%
ZH-kból minimum 63 pont (121 pontból)
Plusz pontokat lehet órai munkával szerezni
Ponthatárok
129 - 147 jeles (5)
111 - 128 jó (4)
92 - 110 közepes (3)
73 - 91 elégséges (2)
0 - 72 elégtelen (1)
Javítási lehetőség nincs
Igazolt hiányzás esetén a ZH pótolható

Előadás
Vizsga feltétele: legalább elégséges gyakorlati jegy
CooSpace teszt
Lesz kifejtős kérdés is
Ponthatárok
88 - 100 jeles (5)
76 - 87 jó (4)
63 - 75 közepes (3)
50 - 62 elégséges (2)
0 - 49 elégtelen (1)
Megajánlott jegy
Jeles (5) gyakorlati jegy esetén jeles vizsgajegy
Jó (4) gyakorlati jegy esetén jó vizsgajegy

Egyéb
Hivatalos kommunikáció
Hivatalos e-mail címről írt levél
CooSpace üzenet
Kérdések
Levél, CooSpace
Discord
Reklamálás
Egyből, amint valami probléma van
48 órán belül e-mailben az előadónak
Speciális képzési igényű hallgatók
SANSZ iroda: https://u-szeged.hu/sansz
Bármilyen kedvezményt az érintett hallgatók csak a SANSZ Iroda
igazolása alapján kaphatnak

Szakirodalom
Online
https://okt.inf.szte.hu/prog2/
http://www.cplusplus.com/
https://en.cppreference.com/w/
Könyvek
Benedek Zoltán - Levendovszky Tihamér: Szoftverfejlesztés C++
nyelven, magyar nyelvű, ISBN 978-963-9131-94-1, Szak Kiadó
Bjarne Stroustrup. A C++ Programozási nyelv
Herbert Schildt: C/C++ Referenciakönyv, magyar nyelvű, Panem Kft
Budapest (1998)
Bruce Eckel. Thinking in C++
Scott Meyers. Effective C++
Scott Meyers. More Effective C++

Tartalom

1 Bevezetés
Bevezető Bevezető
Programozás II. C++ Nyelv 12 / 82

Tartalom

1 Bevezetés
Bevezető Bevezető
Programozás II. C++ Nyelv Bevezetés 13 / 82

C++ története
Kezdetek
1979-ben Bjarne Stroustrup kezdte el kidolgozni

A C nyelv továbbfejlesztése volt
„C with Classes” volt a neve
1983-ban lett C++ a neve
A ++ arra utal, hogy a C nyelvez képest sok új lehetőséggel bővült
1985-ben jelent meg az „első változat”
Nem ISO szabvány
1989-ben jelent meg a 2.0

C++ története
ISO/IEC szabványok
ISO/IEC 14882:1998
Az első szabvány
ISO/IEC 14882:2003
ISO/IEC 14882:2011 (C++0x)
Bjarne Stroustrup: Surprisingly, C++11 feels like a new language: The
pieces just fit together better than they used to and I find a higher-level
style of programming more natural than before and as efficient as ever.
ISO/IEC 14882:2014 (C++1y)
ISO/IEC 14882:2017 (C++1z)
ISO/IEC 14882:2020 (C++2a)
Változások
Elsősorban bővítések
„Nem használt” nyelvi elemek eltávolítása

Hol tart most a C++?
2023. szeptemberében 10,65%-kal a 3. legnépszerűbb nyelv
1. helyezett a Python nyelv (14,16%)
2. helyezett a C nyelv (11,27%)
Forrás: https://www.tiobe.com/tiobe-index/

C és C++ nyelv kapcsolata
Különbségek
A C++ a C továbbfejlesztése
Akkor a C nyelv a C++ nyelv része? NEM
Minden C program lefordítható C++ programként is? NEM
A C++ kulcsszavak problémát okoznak
Szigorúbb „típusellenőrzés”
int * array = malloc (10 * sizeof ( int ) ) ;
Megváltozott „jelentés” (pl. struct)

Ha lefordult, akkor ugyanúgy fut? NEM
Különböző makrók a nyelvekhez
# include < stdio .h >
int main () {
# ifdef __cplusplus
printf ( " C ++ program \ n " ) ;
# else
printf ( " C program \ n " ) ;
# endif
}

C és C++ nyelv kapcsolata
Különbségek nyelvi szinten
Ha pont ugyanazt a kódot fordítjuk, akkor ugyanúgy fut? NEM

Például a karakterliterálokat (’a’, ’b’, ...) másképp kezelik
C-ben egész típus
C++-ban karakter típus
int main () {
if ( sizeof ( 'a ') == sizeof ( int ) )
printf ( " C program \ n " ) ;
else if ( sizeof ( 'a ') == sizeof ( char ) )
printf ( " C ++ program \ n " ) ;
}
Vannak más apró eltérések is

https://www.geeksforgeeks.org/
write-c-program-produce-different-result-c/

C++ nyelv
Programozási paradigmák
Procedurális (C nyelv)
C++-ban is lehet „így” programozni
Azonban még így is bővebb, mint a C
A különbségek ellenére a C++-t a „C folytatásának” tekintjük
Röviden átismételjük
Objektum-orientált (Java)
Hasonló a Javahoz, de sok eltérés van
Javaban könnyebben és hatékonyabban (gyorsabban) lehet programozni
De például ha a performancia számít, akkor C++
Generikus
Az algoritmusokban használt típusok a példányosításnál lesznek
meghatározva
Például Java generikus programozás
Azonban a C++ itt is több, mint a Java
Fordítás idejű számítások

C++ szabvány
A C++ szabvány leírja a C++ nyelvet
Azonban számos esetben (szándékosan) nem definiál minden részletet
Definiálja, hogy az adott konstrukció nem definiált viselkedéshez vezet
Különböző platformokon „másra” van szükség
Például a pointer mérete
32 biten más méretre van szükség, mint 64 biten
Optimalizálási lehetőség
A fordítóprogram könnyebben optimalizálhat
Performancia
Például nincs tömb túlindexelés ellenőrzés
„Gyorsítás”, mert nem ellenőrzi
Veszélyes, mert túlindexelhetjük a tömböt

Implementáció-függő viselkedés
Implementation-defined behavior
A program viselkedése implementáció függő,

de a megvalósításnak dokumentálva kell lennie
Példa: a size_t egy előjeltelen egész szám
typedef /∗ i m p l e m e n t a t i o n −d e f i n e d ∗/ size_t ;
A sizeof operátor visszatérési típusa
Legalább 16 bit
A szabvány nem specifikálja, hogy pontosan hány bájtos legyen
A legnagyobb objektum méretét is tudni kell ábrázolni rajta
Például ha unsigned int típust használunk indexelésre
64 bites rendszereken gond lehet, ha az index nagyobb, mint UINT_MAX

Nem specifikált viselkedés
Unspecified behavior
A program viselkedése implementáció függő,

de a megvalósításnak NEM kell dokumentálva lennie
Szabadság az optimalizációk számára
Bármely kimenet valid eredménynek tekinthető
Példa: a függvény paraméterlistájának kiértékelési sorrendje
int foo () { printf ( " foo " ) ; return 1; }
int goo () { printf ( " goo " ) ; return 1; }
void test ( int , int ) { /* ... */ }
int main () {
test ( foo () , goo () ) ;
}
Lehetséges kimenetek (mindegyik helyes)

GCC 6.3 goo foo
Visual Studio 2017 goo foo
Clang 7.0 foo goo (a foo-t hívja először!!!)

Nem definiált viselkedés
Undefined behavior
A szabvány nem definiálja, hogy mi legyen a program működése

Bármilyen viselkedés lehetséges
A fordítóprogramnak nem feladata ezek felismerése
Példa: előjeles egész szám túlcsordulása
int main () {
int i = INT_MAX ;
printf ( " % d \ n " , i +1) ;
}
Mi lesz a program futásának az eredménye?

Nem definiált viselkedés
Undefined behavior
A szabvány nem definiálja, hogy mi legyen a program működése

Bármilyen viselkedés lehetséges
A fordítóprogramnak nem feladata ezek felismerése
Példa: előjeles egész szám túlcsordulása
int main () {
int i = INT_MAX ;
printf ( " % d \ n " , i +1) ;
}
Mi lesz a program futásának az eredménye?

-2147483648
De valójában nem definiált

Nem definiált viselkedés (folyt.)
Undefined behavior
bool overflow ( int i ) {

return i +1 < i ;
}
int main () {
int i = INT_MAX ;
if ( overflow ( i ) )
printf ( " overflow \ n " ) ;
else
printf ( " % d \ n " , i +1) ;
}
Mi lesz az eredmény?

Nem definiált viselkedés (folyt.)
Undefined behavior
bool overflow ( int i ) { _Z8overflowi :

return i +1 < i ; .LFB12 :
} .cfi_startproc
xorl % eax , % eax
int main () {
int i = INT_MAX ; ret
if ( overflow ( i ) ) .cfi_endproc
printf ( " overflow \ n " ) ;
else
printf ( " % d \ n " , i +1) ;
}
Mi lesz az eredmény?
Az overflow minden esetben hamissal tér vissza
-2147483648
Példák
null pointer dereferencia
Tömb túlindexelés
memcpy, ha a két régió átfedi egymást (C++03)
Tartalom

1 Bevezetés
Bevezető Bevezető
Programozás II. Ismétlés, eltérések 25 / 82

Tartalom

1 Bevezetés
Bevezető Bevezető
Programozás II. Ismétlés, eltérések Bevezető 26 / 82

Fejlesztőkörnyezet, fordítóprogram
Szinte minden platform támogatott
Windows, Linux, iOS, Android, beágyazott rendszerek, ...
Fordítóprogramok
Visual Studio parancssori eszközök
cl, link, msbuild, devenv
GCC, the GNU Compiler Collection
C esetében a fordítóprogram a gcc
C++ esetében a fordítóprogram a g++
Clang
Fejlesztő környezetek
Eclipse, Code::Blocks, CodeLite, Visual Studio Code, ...
Nyílt forráskódú, platformfüggetlen
Visual Studio (Windows)

Forrás fájlok, GCC fordító
Fájlok kiterjesztése
C esetében
forrás fájl: .c
header fájl: .h
C++ esetében
forrás fájl: .cpp (.C, .cxx, .cc, .c++)
header fájl: .hpp (.h)
A fordítóprogram a kiterjesztés alapján dönti el, hogy C vagy C++
programként kezelje a kódot
Felül lehet bírálni
GCC esetében a -x kapcsolóval
g++ -x c++ pelda.c esetén C++ inputnak fogja tekinteni a pelda.c
fájlt

Program belépési pontja
Visszatérési érték
Program belépési pontja C és C++ esetén is a main függvény

int main ( ) { /∗ . . . ∗/ }
int main ( int argc , char ∗ argv [ ] ) { /∗ . . . ∗/ }
Implementáció-függő megvalósítás
int main ( int argc , char ∗ argv [ ] , char ∗ env [ ] ) {}
Visszatérési érték
0 jelzi a helyes futást
Minden más érték hibát jelez
Visszatérési érték megadása
C esetében kiírtuk, még ha 0-val térünk vissza akkor is
Már itt is elhagyható
C++ esetében, ha a program futása eléri a main függvény végét
(main-ben található) return utasítás nélkül, akkor a program 0-val
tér vissza
Nem kell kiírni a return 0 ; -t
Ennek ellenére érdemes kiírni
A diákon hely hiányában nem lesz kiírva
Tartalom

1 Bevezetés
Bevezető Bevezető
Programozás II. Ismétlés, eltérések I/O műveletek 30 / 82

I/O műveletek
C nyelv
Beolvasás
int scanf ( const char ∗ format , . . . )
int fscanf ( FILE ∗ stream , const char ∗ format , ...)
Kiírás
int printf ( const char ∗ format , . . . )
int fprintf ( FILE ∗ stream , const char ∗ format , ...)
Példa
int main () {
int i , j ;
scanf ( " % d % d " , &i , & j ) ;
printf ( " % d * % d = % d \ n " , i , j , i * j ) ;
return 0;
}

I/O műveletek
C++ nyelv
A C++ Standard Template Library (STL) része

Folyamok (stream-ek) segítségével valósítja meg
Szabványos bemenet/kimenet (iostream header)
cin szabványos bemenet folyam
cout szabványos kimenet folyam
cerr szabványos hiba (kimenet) folyam
clog szabványos logging (kimenet) folyam
Fájl írása, olvasása (fstream header)
ifstream - stream fájlok olvasására
ofstream - stream fájlok írására
fstream - stream fájlok olvasására és írására
String folyam (sstream header)
stringstream

C++ szabványos bemenet/kimenet
# include < iostream >
int main () {
int i , j ;
std :: cin >> i >> j ;
std :: cout << i << " * " << j << " = " << i * j << std :: endl ;
}
iostream header fájlt kell include-olni

Az std névtérben találhatóak az I/O folyamok
Scope-olt névvel kell rájuk hivatkozni
std : : (a : : a scope-olás)
A >> és << operátorok segítségével olvasunk és írunk
Az operátor az adott olvasás/írás után a stream-mel tér vissza, azaz
újból alkalmazhatjuk rá az operátort
int i = a ∗ b ∗ c ∗ d ; // a , b , c , d e g e s z
Az endl a sorvége
C++ szabványos bemenet/kimenet (folyt.)
using namespace std ;
int main () {
int i , j ;
cin >> i >> j ;
cout << i << " * " << j << " = " << i * j << endl ;
}

A fordító az azonosítók feloldásakor az std névtérben is keresni fog
Nem kell kiírni az std-t
Ki lehet írni, nem okoz gondot

Tartalom

1 Bevezetés
Bevezető Bevezető
Programozás II. Ismétlés, eltérések C++ string 35 / 82

C „string”
N hosszú karaktersorozat tárolása (str változóban)
char ∗ str = malloc ( N+1) ; // d i n a m i k u s
char str [ N + 1 ] ; // " s t a t i k u s "
Beolvasás
scanf ( "%s" , str ) ;
Értékadás
str = str2 ; HIBÁS!
strcpy ( str , str2 ) ; vagy strncpy ( str , str2 , n ) ;
Honnan tudjuk a méretet? Mi van, ha nem fér el?
str és str2 nem fedheti át egymást
Összehasonlítás
str = = str2 (két egyenlőségjel) nem a tartalmat hasonlítja össze
strcmp ( str , str2 ) a tartalom szerinti összehasonlítás
Max. kapacitása?
strlen ( str ) a tárolt szöveg hosszát adja meg
A kapacitást (általában) nem ismerjük
Memória felszabadításra is figyelni kell dinamikus foglalásnál
C++ string
Van „valódi” string
Sokkal egyszerűbben használható, mint a „C-string”
A C++ Standard Template Library (stl) része
Az std névtérben található
# include < string >

int main () {
string s1 = " Hello " ;
string s2 ( " Vilag " ) ;
string s3 ;
s3 = s1 + " " + s2 + " ! " ;

cout << s3 << endl ; // Hello Vilag !
}

C++ string
Konstruktorok
string ( ) ;
string ( const string& str ) ;
string ( const char ∗ s ) ;
Méret (tárolt string hossza)
size_t size ( ) ;
size_t length ( ) ;
Üres-e?
bool empty ( ) ;
Törlés
void clear ( ) ;
char ∗ reprezentáció
const char ∗ c_str ( ) ;
Rész string
string substr ( size_t p = 0 , size_t l = npos ) ;
p a kezdő pozíció, l a hossz
C++ string
Első karakter
char& front ( ) ;
Utolsó karakter
char& back ( ) ;
i-edk karakter
char& operator [ ] ( size_t pos ) ;
char& at ( size_t pos ) ;
Keresés
size_t find_first_of ( char c , size_t pos = 0 ) ;
find_last_of, find_first_not_of, find_last_not_of
„Vége”
npos attribútum
Például keresésnél ezzel tudjuk megnézni, hogy volt-e találat

C++ string
# include < iostream > // bemenet
# include < string > // programozas
// kimenet
using namespace std ; // programozas hossza : 11
// programozas elso karaktere : p
int main () { // 'a ' elso elofordulasa : 5
string s ; // [2 -4]: rog
cin >> s ; // torles utan : ''
cout << s << " hossza : " << s . length () << endl ;
if (! s . empty () )
cout << s << " elso karaktere : " << s [0] << endl ;
size_t pos = s . find_first_of ( 'a ') ;
if ( pos != string :: npos )
cout << " 'a ' elso elofordulasa : " << pos << endl ;
if (4 < s . length () )
cout << " [2 -4]: " << s . substr (1 , 3) << endl ;
s . clear () ;
cout << " torles utan : '" << s << " '" << endl ;
}

Szám konverziója string-gé
A string és a szám típusok között nincs automatikus konverzió
string s = 5 ; nem alkalmazható
Nem volt a C-string esetében sem
string to_string ( int value ) ; függvény segítségével a
számokat string-gé lehet konvertálni
Nem a string osztály metódusa (de az std névtérben van)
Minden szám típusra alkalmazható (ennyi különböző függvény meg van
valósítva)
int , long , long long , unsigned , unsigned long ,
unsigned long long , float , double , long double
Példa
int main () {
int i = 5;
string s1 = to_string ( i ) ;
string s2 = to_string (3.14) ;
cout << s1 << " " << s2 << endl ;
}
// 5 3.140000

string konverziója számmá
A string típus nem konvertálódik automatikusan egésszé
string str ( " 4 " ) ;
int i = str ; // HIBA !
int stoi ( const string& str ,

size_t ∗ pos = 0 , int base = 10 ) ;
str: a string, amit számmá kell konvertálni
pos: hány karakter lett feldolgozva
base: a számrendszer alapja (2, 3, 4, ..., 36)
A 0 azt jelenti, hogy automatikusan kell felismernie
Példa
int main () {
string s1 ( " 12345 " ) ;
int i = stoi ( s1 ) ;
cout << i << endl ;
}
// 12345

string konverziója számmá (folyt.)
Példa
int main () {
string s1 ( " + FF alma " ) ;
unsigned int chars = 0;
int i = stoi ( s1 , & chars , 16) ;

cout << i << " " << chars << endl ;
}
Eredmény: 255 3
16-os számrendszerben az FF az 255 10-es számrendszerben
3 karakter lett feldolgozva (a + jel is)
További konverziók
int: stoi, long: stol, long long: stoll
unsigned long: stoul, unsigned long long: stoull
float: stof, double: stod, long double: stold

Hibakezelés
Kétféle hiba léphet fel
Nem lehet konvertálni
std : : invalid_argument kivétel dobódik
try {
string s1 ( " alma " ) ;
cout << stoi ( s1 ) << endl ;
} catch ( const invalid_argument & e_inv ) {
cout << " invalid_argument exception " << endl ;
}
Nem fér bele az adott tartományba

std : : out_of_range kivétel dobódik
try {
string s1 ( " 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 " ) ;
cout << stoi ( s1 ) << endl ;
} catch ( const out_of_range & e_out ) {
cout << " out_of_range exception " << endl ;
}

Tartalom

1 Bevezetés
Bevezető Bevezető
Programozás II. Objektum-orientált C++ 45 / 82

Tartalom

1 Bevezetés
Bevezető Bevezető
Programozás II. Objektum-orientált C++ Bevezető 46 / 82

Objektum-orientált programozás
Egységbezárás
Az összetartozó adatokat és a rajtuk végezhető műveleteket egy
egységként kezeljük
Öröklődés
Az osztályok öröklődéssel újrafelhasználhatóak
Új adattagokkal és operációkkal kibővíthetőek
Meglévő operációkat felül lehet definiálni
Polimorfizmus
Futás közben dől el, hogy pontosan melyik operáció hajtódik végre

Objektum
Az objektum egy entitás ábrázolása
Kutya, ember, kurzus, tárgy, ...
Minden objektumnak van
Állapota
Egy a lehetséges létezései közül
Időben változó
Attribútumok határozzák meg
Példa: a kutyának van neve és születési dátuma
Viselkedése
Annak módja, hogyan reagál egy objektum más objektumok kéréseire
Mindent definiál, amit az objektum „csinálhat”
Operációk határozzák meg
Egy Kutya típusú objektumnak lehetnek eszik vagy sétál operációi
Identitása
Minden objektum egyedi, akkor is, ha az állapotuk azonos
Lehet két azonos nevű kutya, de azok attól különbözők
A típusuk és az attribútumaik azonosak
Osztály fogalma
Leírás objektumok csoportjához, amelyeknek közösek az
Attribútumaik, operációik
Más objektumokkal való kapcsolataik és
Szemantikus viselkedésük
Egy minta objektumok létrehozásához (példányosításához)
Minden objektum pontosan egy osztály példánya
Az osztály az objektum típusa

C++ osztály
A class kulcsszóval definiálhatunk osztályokat
Meg kell adni az osztály
nevét
Kutya
attribútumait (és azok típusait)
int szul_ev ; string szin , nev ;
tagfüggvényit
definíció: void eszik ( ) { /∗ . . . ∗/ }
deklaráció: void elkeresztel ( string s ) ;
class Kutya {
int szul_ev ; // adattag ( attributum )
string szin , nev ; // adattag ( attributum )
void eszik () { // metodus ( tagfuggveny )
/* ... */
}
void elkeresztel ( string s ) ; // metodus deklaracio
}; // pontosvesszo !

Objektum létrehozása, tagok elérése
Ha definiáltunk egy osztályt, akkor azt példányosíthatjuk
Létrejön egy új objektum, aminek a típusa az adott osztály lesz
Minden objektum példány egyedi
Ha az attribútumaik megegyeznek, akkor is két külön objektum létezik
class Kutya { /* ... */ };
Kutya morzsi , mancs ; // ket objektum letrehozasa
Az adott objektumnak
Meg lehet hívni a metódusait
morzsi . eszik () ;
Hozzá lehet férni az attribútumaihoz

A pont (.) operátor segítségével
morzsi . szul_ev = 2018;

cout << " A kutya szine : " << morzsi . szin << endl ;

Láthatóság
Az adott osztály tagjainak meg lehet adni a láthatóságát
public
Mindenki számára korlátozás nélkül elérhető
protected
Csak az adott osztályból és a leszármazott osztályból érhető el
private
Csak az adott osztályból érhető el
Nem egy adott elemre kell megadni, hanem a „szekcióra”
Addig érvényes az előző, amíg újat nem definiálunk
Megadása: láthatóság és kettőspont
class Kutya {
public : // lathatosag megadasa
void eszik () ; // publikus
};
class esetében az alapértelmezett láthatóság a private

Ha nem írjuk ki, akkor private
Láthatóság
Példa
class Kutya {
int szul_ev ; // private , mivel nem adtuk meg
string szin ; // private , mivel nem adtuk meg
private :
bool him ; // private ( megadtuk )
public :
void eszik () ; // public
void elkeresztel ( string s ) ; // public
public :
void setal () { // public
/* ... */
}
public :
protected :
string nev ; // protected
public :
};

További hozzáférés biztosítása
A láthatóságok megadásával azt adjuk meg, hogy az adott tagnak mi
lesz a láthatósága
Azt mondjuk meg, hogy mi érhető el az osztályból
A protected „korlátozza csak a hozzáférők körét”
A public tagokat bármely másik osztály vagy metódus elérheti
Míg a private csak az adott osztályból látható
Hogyan oldjuk meg, hogy ha a hozzáférést szeretnénk adni egy
bizonyos osztálynak vagy függvénynek?
Például a Kutya osztálynak lenne egy void beolt ( ) metódusa
Ha publikus lenne, akkor bárki beolthatná
Ha nem lenne publikus, akkor az állatorvos sem olthatná be

friend mechanizmus
Lehetőség van hozzáférést biztosítani az osztályhoz másik
osztályoknak, függvényeknek vagy metódusoknak
A friend kulcsszó használatával adhatjuk meg
Az adott osztályon belül kell megadni
Mindenhez hozzáfér
Nem tudjuk korlátozni, hogy csak „bizonyos” tagokhoz férjen hozzá
Annak ellenére, hogy az adott osztályon belül adjuk meg a
friend-eket, azok nem az osztály részei
class Kutya {
friend void orvos_beolt ( Kutya & k ) { /* ... */ }
/* ... */
};
int main () {
Kutya kutya ;
orvos_beolt ( kutya ) ; // ez a helyes hivas
kutya . orvos_beolt ( kutya ) ; // nincs orvos_beolt metodus
}

friend függvény
Példa
class Kutya {
int egeszseg = 100;
void beolt () { egeszseg ++; }
friend void orvos_beolt ( Kutya & k ) ;
friend void allatorvos_beolt ( Kutya & k ) { k . egeszseg ++; }
};
void orvos_beolt ( Kutya & k ) { k . beolt () ; }
int main () {
Kutya kutya ;
orvos_beolt ( kutya ) ;
allatorvos_beolt ( kutya ) ;
kutya . egeszseg ++; // HIBA , az egeszseg private

kutya . allatorvos_beolt () ; // HIBA , nincs ilyen metodus
kutya . allatorvos_beolt ( kutya ) ; // HIBA , nincs ilyen met .
}

friend osztály
Példa
class Kutya {
int egeszseg = 100;
void beolt () { egeszseg ++; }
friend class Allatorvos ;
};
class Allatorvos {
public :
void beolt ( Kutya & k ) { k . egeszseg ++; }
};
class Gazda {
void beolt ( Kutya & k ) { k . egeszseg ++; } // HIBA
};
int main () {
Kutya k ;
Allatorvos orvos ;
orvos . beolt ( k ) ;
}

Interfész és implementáció
Fontos, hogy szétválasszuk az interfészt az implementációtól
Interfész
Milyen funkcionalitást biztosít az adott osztály vagy modul
Felhasználás szempontjából ez a fontos
Implementáció
Hogyan valósítja meg az adott funkcionalitást
A felhasználás szempontjából „mindegy”
Futásidő, memóriahasználat, stb. azért lényeges
Az implementációt el is szokták „rejteni”
C esetében
A header fájlokban deklaráljuk a függvényeket (rendezes.h)
void rendezes ( int ∗ tomb ) ;
A forrásfájlokban implementáljuk azokat (rendezes.c)
void rendezes ( int ∗ tomb ) { /∗ m e g v a l o s i t a s ∗/ }
include-olás után használhatom a rendezes függvényt
Az implementáció rejtve marad (esetleg csak binárisan elérhető)

Osztály interfésze
Osztályok esetében is lehetőség van szétválasztani az interfészt az
implementációtól
Osztály interfésze a funkcionalitását határozza meg
Milyen funkcionalitásokat biztosít
Az összeset definiálni kell
Az osztály definíciónál meg kell adni
Az adattagok
Metódus deklarációk
Egyszerűbb metódusokat meg is valósíthatunk (de nem kötelező)
friend deklarációk
Típus deklarációk, ...
Az osztály definíciója (tipikusan) header fájlokban található
Ha használni szeretnénk, akkor ezt a header fájlt kell include-olni
Az implementáció nélkül már lehet használni

Osztály interfész
Példa
class Kutya {
int egeszseg , szul_ev ;
// A kutya beoltasa
void beolt () ;
public :
/* *
* A kutya egeszseget adja meg .
*/
int get_egeszseg () ;
/* *
* A kutya szuletesi evet adja meg .
*/
int get_szul_ev () ;
friend void orvos_beolt ( Kutya & k ) ;

friend class Orvos ;
};

Osztály funkcionalitásának megvalósítása
Metódusok implementálása
Lehetőségünk van az „osztályon kívül” implementálni a metódusait

Csak a program forráskódjában kerül másik helyre, az implementáció az
osztály része lesz
A metódusok szignatúráján nem változtathatunk
Név
Paraméterek száma és típusa
Visszatérési típus
Módosítók
Az implementációnál meg kell adni, hogy melyik osztály metódusáról
van szó
A metódus neve elé ki kell írni a scope-ot
Példa void Kutya::beolt ( ) { /∗ . . . ∗/ }
Általában a header fájllal egyező nevű forrásfájlban (.cpp) fájlban
szokták megvalósítani
Ez csak ajánlás, akár több fájlban is megvalósíthatjuk
include-olni kell a header fájlt

Osztály metódusok implementálása
friend implementálása
class Kutya { # include " kutya . hxx "

int egeszseg , szul_ev ;
// A kutya beoltasa void Kutya :: beolt () {
void beolt () ; egeszseg ++;
public : }
/* *
* A kutya egeszseget ... int Kutya :: get_egeszseg () {
*/ return egeszseg ;
int get_egeszseg () ; }
/* *
* A kutya szuletesi evet ... int Kutya :: get_szul_ev () {
*/ return szul_ev ;
int get_szul_ev () ; }
friend void void orvos_beolt ( Kutya & k ) {

orvos_beolt ( Kutya & k ) ; /* ... */
friend class Orvos ; }
};

Header fájl védőfeltételek
Makró és pragma
A header fájlokban találhatóak azok a deklarációk és definíciók,

amelyeket szeretnénk használni
Osztály, függvény, típus, makró, ...
A header fájlok egymást is használhatják
Előfordulhat, hogy ilyen függőségek következtében egy header fájlt
többször is include-olunk
Lehetnek olyan deklarációk, amelyek nem fordulhatnak elő többször
Makró, typedef
Meg kell akadályozni, hogy ezeket többször definiáljuk
C esetében makrókat használtunk
A makrókat lehet C++-ban is használni
Másik lehetőség a pragma használata
A header fájl elejére be kell írni, hogy csak „egyszer vegye figyelembe”
# pragma once
// ...

Header fájl védőfeltételek
Példa
Makró (kutya.h) Pragma (kutya.h)

# ifndef KUTYA_H # pragma once
# define KUTYA_H
class Kutya {
class Kutya { /* ... */
/* ... */ };
};
# endif /* KUTYA_H */
Melyiket használjuk?
Röviden: mindegy, mind a kettő elterjedt és támogatott
A pragma nem része a szabványnak, de a legtöbb fordító támogatja
„Nehezebb elrontani”
Ha van ugyanolyan nevű header fájl külön könyvtárban, akkor a fájl
nevéből képzett makró megegyezhet

Tartalom

1 Bevezetés
Bevezető Bevezető
Programozás II. Objektum-orientált C++ Konstruktor, destruktor 65 / 82

Osztályok példányosítása
Az osztályok példányosításával objektumokat hozhatunk létre
Az objektumok van állapota
Az adattagjai határozzák meg
Általában ezeket az adattagokat inicializálni kell az objektum
létrejöttekor
Lehetne két lépésben is, hogy előbb létrehozzuk, majd inicializáljuk
A két lépés felesleges
const adattagokat létrehozás után nem lehet módosítani
Referenciát kötelező inicializálni
Hasonlóan az objektum megszűnésekor is lehetnek olyan műveletek,
amelyeket végre kell hajtani
Például memória felszabadítás
A megszűnést nem is olyan egyszerű „ellenőrizni”
Nem tudjuk mikor kellene a felszabadító függvényt meghívni

Konstruktor
Az osztálynak definiálhatunk konstruktort, amely az osztály
példányosításakor fut le
A konstruktor egy speciális tagfüggvény
A neve meg kell egyezzen az osztály nevével
Nem lehet visszatérési típusa
Nem hívható közvetlenül
Automatikusan hívódik
Nem lehet const
Nem lehet static
Viszont általános olyan tekintetben, hogy
Megadhatjuk a láthatóságát
Lehetnek paraméterei
Lehet több konstruktor is
Operator overloading
A paraméter nélküli konstruktort default konstruktornak hívják
Ha nem adunk meg konstruktort, akkor a fordító generál egy default-ot

Konstruktor példa
class Kutya { int main () {

string nev ; Kutya k1 ;
int szul_ev ; Kutya k2 ( " Bloki " ) ;
public : Kutya k3 (2018) ;
Kutya () { Kutya k4 ( " Morzsi " , 2017) ;
nev = " ismeretlen " ; }
szul_ev = 2023;
}
Kutya ( string nev ) {
this - > nev = nev ;
szul_ev = 2023;
}
Kutya ( int ev ) {
nev = " ismeretlen " ;
szul_ev = ev ;
}
Kutya ( string nev , int ev ) {
this - > szul_ev = ev ;
}
};

Konstruktor (folyt.)
Csak azokat a konstruktorokat hívhatjuk, amelyek definiálva vannak
Paraméterlista alapján dől el, hogy melyik hívódik
Ahogy a függvények esetében is
A default konstruktor hiánya
class Kutya {
string nev ;
int szul_ev ;
public :
Kutya ( string nev , int ev ) {
}
};
int main () {
Kutya k1 ; // HIBA ! nincs megfelelo konstruktor
Kutya k2 ( " Bloki " ) ; // HIBA ! nincs megfelelo konstruktor
Kutya k3 (2018) ; // HIBA ! nincs megfelelo konstruktor
Kutya k4 ( " Morzsi " , 2017) ;

Konstruktor
Példa javítása
Nem csak a paraméter nélküli konstruktorral lehet megoldani

Lehet default értékeket adni a paramétereknek
class Kutya {
string nev ;
int szul_ev ;
public :
Kutya ( string nev = " ismeretlen " , int ev = 2023) {
}
};
int main () {
Kutya k1 ;
Kutya k2 ( " Bloki " ) ;
Kutya k3 (2018) ; // HIBA ! nincs megfelelo konstruktor
Kutya k4 ( " Morzsi " , 2017) ;
}

Konstruktor inicializáló lista
Miért kell?
Az adattagok inicializálást nem a konstruktor törzsében szokták

elvégezni
Konstans adattagot nem változtathatunk meg a konstruktor törzsében
class Kutya {
string nev ;
const int szul_ev ; // HIBA !
public :
Kutya ( const string & nev , int szul_ev ) {
this - > szul_ev = szul_ev ; // HIBA !
}
};
Kutya k ( " Morzsi " , 2018) ;
Fordítási hiba: a const adattagot inicializálni kell

Konstruktor inicializáló lista
Az adattagokat a konstruktor inicializáló listában kell (lehet)
inicializálni
A paraméter lista után kettőspont (:)
Majd az adattagok felsorolva és zárójelben az értékük
A felsorolást vesszővel kell elválasztani
class Kutya {
string nev ;
const int szul_ev ;
public :
Kutya ( const string & nev , int szul_ev ) :
nev ( nev ) , szul_ev ( szul_ev ) {
}
};
Ami megegyezik ezzel

Kutya ( const string & p_nev , int p_szul_ev ) :
nev ( p_nev ) , szul_ev ( p_szul_ev ) {

Konstruktor inicializáló lista sorrendje
Az adattagok abban a sorrendben kapnak értéket, ahogy az
osztályban definiálva vannak
Azaz nem abban a sorrendben hajtódik végre, ahogy a listában fel
vannak sorolva az adattagok
class Kutya {
int ev , honap , nap ;
public :
Kutya () : nap (1) , honap ( nap ) , ev ( honap ) {
// ev = honap ; // HIBA ! honap definialatlan
// honap = nap ; // HIBA ! nap definialatlan
// nap = 1;
}
};
A fordító warning üzenetet ad

Adattagok inicializálása
Default member initialization
Az adattagoknak lehet értéket adni egyszerűen egyenlőséggel

Akkor kapja meg ezt az értéket, ha a konstruktor inicializáló listában
nem adunk neki értéket
class Kutya {
int ev = 2023 , honap = 1 , nap = 1;
public :
Kutya () {
}
Kutya ( int ev , int honap , int nap ) :
ev ( ev ) , honap ( honap ) , nap ( nap ) {
}
};
int main () {
Kutya k0 ;
Kutya k1 (2023 , 9 , 19) ;
}

Delegating konstruktor
Az egyik konstruktorból meg lehet hívni a másikat
A konstruktor inicializáló listában kell megadni, hogy melyiket hívjuk
Ilyenkor nem inicializálhatjuk az adattagokat
Előnye, hogy nem kell a kódot duplikálni
Kevesebb a hibalehetőség
class Kutya {
int ev , honap , nap ;
public :
Kutya () : Kutya (2023 , 9 , 19) {
}
Kutya ( int ev , int honap , int nap ) :

ev ( ev ) , honap ( honap ) , nap ( nap ) {
/* hosszu , bonyolult algoritmus */
}
};

Nem publikus konstruktor
A konstruktor láthatóságát is változtathatjuk
Lehet például private is
Ilyenkor az osztályon kívülről nem lehet példányosítani
Mire jó, ha kívülről nem lehet példányosítani?
Akkor hogyan használjam?
class Singleton {
Singleton () {}
public :
static Singleton & getInstance () {
static Singleton instance ;
return instance ;
}
};
int main () {
Singleton s1 = Singleton :: getInstance () ;
Singleton s2 ; // HIBA !
}

Példányosítás megakadályozása
Mi van akkor, ha meg akarom tiltani a példányosítást
A nem publikus konstruktor nem megoldás
class Example {
Example () { }
public :
void foo () {
Example e ; // Example peldanyositasa
}
};
delete konstruktor
class Example {
Example () = delete ;
public :
void foo () {
Example e ; // HIBA !
}
};

Default konstruktor hiánya
Ha nincs default konstruktor, akkor nem példányosíthatjuk az osztályt
úgy, hogy a default konstruktor hívódik automatikusan
Kutya kutya ;
Kutya ∗ kutya = new Kutya ;
class Tulajdonos { Kutya kutya ; } ;
Egyik megoldás lehet, hogy a megfelelő konstruktort használjuk
Kutya kutya ( " Bloki " ) ;
Kutya ∗ kutya = new Kutya ( " Bloki " ) ;
A konstruktor inicializáló listában kell meghívni a megfelelő konstruktort
class Tulajdonos {
Kutya kutya ;
public :
Tulajdonos ( const string & nev ) : kutya ( nev ) { }
};
Ha lehet (van értelme), akkor a default konstruktort is

megvalósíthatjuk
Ilyenkor az eredeti megoldás is használható
Nem biztos, hogy midig van értelme a default konstruktornak
Hallgató létrehozása adatok (név, azonosítók, ...) nélkül
Default konstruktor hiánya
Amikor nem lehet példányosítani
Ha nincs default konstruktor, akkor tömböket „nem tudunk

létrehozni”
Dinamikus létrehozáskor
Minden elem esetében meghívódik a default konstruktor
Kutya * kutyak = new Kutya [10];
Default konstruktor nélkül nem lehet használni

A Kutya kutyak [ 1 0 ] ; esetében is a default konstruktor hívódik
Itt „megoldás” lehet, hogy a tömb minden egyes elemét létrehozáskor
inicializáljuk
Kutya k [2] = { Kutya ( " Morzsi " ) , Kutya ( " Bloki " ) };
Nem az igazi megoldás

Nagy tömb esetén „nem” használható
Mi van, ha nem tudjuk inicializálni?

Destruktor
A destruktor az objektum megszűnésekor fut le
Automatikusan hívódik
A destruktor
Neve meg kell egyezzen az osztály nevével, csak egy tilde van előtte
Nincs visszatérési típusa
Ahogy a konstruktornak sem volt
Nincsenek paraméterei
De az üres paraméter listát ki kell írni
Csak egy destruktor lehet
Ha nem írjuk ki, akkor a fordító generál egyet
Láthatóságát ugyanúgy lehet szabályozni

Destruktor
Példa
class Kutya {
string nev ;
public :
Kutya ( const string & nev ) : nev ( nev ) {
cout << " Constructor : " << nev << endl ;
}
~ Kutya () {
cout << " Destructor : " << nev << endl ;
}
};
// Kimenet :
int main () { // Constructor : Morzsi
Kutya morzsi ( " Morzsi " ) ; // Constructor : Bloki
Kutya bloki ( " Bloki " ) ; // Destructor : Bloki
} // Destructor : Morzsi

Dinamikus példányosítás és megszüntetés
Dinamikus példányosítás (new) esetében is automatikusan hívódik a
megfelelő konstruktor
Csak a megvalósított konstruktorokat lehet „használni”
Törlés (delete) esetében automatikusan hívódik a destruktor
class Kutya {
string nev ;
public :
Kutya ( const string & nev ) : nev ( nev ) {
cout << " Constructor : " << nev << endl ;
}
~ Kutya () {
cout << " Destructor : " << nev << endl ;
}
};
int main () { // Kimenet :

Kutya * kutya = new Kutya ( " Bloki " ) ; // Constructor : Bloki
delete kutya ; // Destructor : Bloki
}

ProgII 02

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ProgII 02

Uploaded by

Copyright:

Available Formats

Programozás II.

Dr. Siket István

Bevezetés C++ string

Programozás II. Bevezetés 2 / 82

Bevezetés C++ string

Programozás II. Bevezetés Kurzus információk 3 / 82

Programozás II. Bevezetés Kurzus információk 4 / 82

Programozás II. Bevezetés Kurzus információk 5 / 82

Minden gyakorlaton pont ugyanaz az anyag lesz

Programozás II. Bevezetés Kurzus információk 6 / 82

Kvíz (CooSpace kérdések)

Programozás II. Bevezetés Kurzus információk 7 / 82

Elégséges jegyhez követelmény

Programozás II. Bevezetés Kurzus információk 8 / 82

Programozás II. Bevezetés Kurzus információk 9 / 82

Programozás II. Bevezetés Kurzus információk 10 / 82

Programozás II. Bevezetés Kurzus információk 11 / 82

Bevezetés C++ string

Programozás II. C++ Nyelv 12 / 82

Bevezetés C++ string

Programozás II. C++ Nyelv Bevezetés 13 / 82

1979-ben Bjarne Stroustrup kezdte el kidolgozni

Programozás II. C++ Nyelv Bevezetés 14 / 82

Programozás II. C++ Nyelv Bevezetés 15 / 82

Programozás II. C++ Nyelv Bevezetés 16 / 82

Megváltozott „jelentés” (pl. struct)

Programozás II. C++ Nyelv Bevezetés 17 / 82

Ha pont ugyanazt a kódot fordítjuk, akkor ugyanúgy fut? NEM

# include < stdio .h >

Vannak más apró eltérések is

Programozás II. C++ Nyelv Bevezetés 18 / 82

Programozás II. C++ Nyelv Bevezetés 19 / 82

Programozás II. C++ Nyelv Bevezetés 20 / 82

A program viselkedése implementáció függő,

Programozás II. C++ Nyelv Bevezetés 21 / 82

A program viselkedése implementáció függő,

Lehetséges kimenetek (mindegyik helyes)

Programozás II. C++ Nyelv Bevezetés 22 / 82

A szabvány nem definiálja, hogy mi legyen a program működése

Mi lesz a program futásának az eredménye?

Programozás II. C++ Nyelv Bevezetés 23 / 82

A szabvány nem definiálja, hogy mi legyen a program működése

Mi lesz a program futásának az eredménye?

Programozás II. C++ Nyelv Bevezetés 23 / 82

bool overflow ( int i ) {

Programozás II. C++ Nyelv Bevezetés 24 / 82

bool overflow ( int i ) { _Z8overflowi :

Bevezetés C++ string

Programozás II. Ismétlés, eltérések 25 / 82

Bevezetés C++ string

Programozás II. Ismétlés, eltérések Bevezető 26 / 82

Programozás II. Ismétlés, eltérések Bevezető 27 / 82

Programozás II. Ismétlés, eltérések Bevezető 28 / 82

Program belépési pontja C és C++ esetén is a main függvény

Bevezetés C++ string

Programozás II. Ismétlés, eltérések I/O műveletek 30 / 82

Programozás II. Ismétlés, eltérések I/O műveletek 31 / 82

A C++ Standard Template Library (STL) része

Programozás II. Ismétlés, eltérések I/O műveletek 32 / 82

iostream header fájlt kell include-olni

using namespace std ;

using namespace std ;

Programozás II. Ismétlés, eltérések I/O műveletek 34 / 82