Programozás. (GKxB_INTM021) Dr. Hatwágner F. Miklós április 4. Széchenyi István Egyetem, Gy r

Átírás

1 Programozás (GKxB_INTM021) Széchenyi István Egyetem, Gy r április 4.

2 Számok rendezése Feladat: Fejlesszük tovább úgy a buborék rendez algoritmust bemutató példát, hogy a felhasználó adhassa meg a rendezend adatokat! (Adatbevitelnek vége negatív adatra.) Nem adhat meg több számot, mint a tömb elemszáma! Problémák: Fordítási id ben tudni kellene a rendezend adatok számát Túl kicsi tömb nem férnek el az adatok Túl nagy tömb pazaroljuk a memóriát Inkább nagyobb legyen a tömb, mint túl kicsi!

3 Számok rendezése Kimenet1 Adjon meg nemnegativ szamokat! 1. szam: 2 2. szam: 4 3. szam: 1 4. szam: 3 5. szam: -1 Rendezes utan: Kimenet2 Adjon meg nemnegativ szamokat! 1. szam: 5 2. szam: 4 3. szam: 3 4. szam: 2 5. szam: 1 Rendezes utan:

4 Számok rendezése 3 #d e f i n e OSSZES 5 37 i n t main ( ) { 38 i n t h a s z n a l ; // E n n y i e l e m e t h a s z n a l u n k eppen 39 i n t szamok [ OSSZES ] ; 40 c o u t << " Adjon meg n e m n e g a t i v szamokat! \ n" ; 41 b e o l v a s ( szamok, &h a s z n a l ) ; 42 b u b o r e k ( szamok, h a s z n a l ) ; 43 c o u t << " R endezes utan : \ n" ; 44 t o m b K i i r ( szamok, h a s z n a l ) ; 45 r e t u r n 0 ; 46 }

5 Számok rendezése 5 v o i d b e o l v a s ( i n t szamok, i n t h a s z n a l ) { 6 i n t u j ; 7 h a s z n a l = 0 ; 8 do { 9 c o u t << h a s z n a l + 1 << ". szam : " ; 10 c i n >> u j ; 11 i f ( uj >=0 and h a s z n a l <OSSZES) { 12 ( szamok + h a s z n a l ) = u j ; 13 ( h a s z n a l )++; 14 } 15 } w h i l e ( uj >=0 and h a s z n a l <OSSZES ) ; 16 }

6 Dinamikus memóriakezelés Dinamikus memóriakezelés A programozó dönt a dinamikus változók élettartamáról Memória foglalás: new operátorral Visszaadott mutató típusa: mindig megfelel, nincs szükség típuskényszerítésre Sikertelen memóriafoglalás esetén NULL értéket kapunk ellen rizni kell Terület felszabadítása: delete Ugyanaz a terület nem szabadítható fel többször NULL mutató felszabadítása nem okoz gondot

7 Dinamikus memóriakezelés 5 char pc ; // d e k l a r a c i o k 6 i n t p i ; 7 double pd ; 8 9 pc = new char ; // m e m o r i a f o g l a l a s o k 10 p i = new i n t ; 11 pd = new double ; i f ( pc == NULL) { // e l l e n o r z e s 14 c e r r << " S i k e r t e l e n m e m o r i a f o g l a l a s! \ n" ; 15 r e t u r n 1 ; 16 }

8 Dinamikus memóriakezelés 18 pc = 'X ' ; // e r t e k a d a s o k 19 p i = 4 2 ; 20 pd = ; d e l e t e pc ; // memoria f e l s z a b a d i t a s 23 d e l e t e p i ; 24 d e l e t e pd ; A lefoglalt terület inicializálható 9 pc = new char ( 'X ' ) ; // m e m o r i a f o g l a l a s o k 10 p i = new i n t ( 4 2 ) ; // i n i c i a l i z a c i o k 11 pd = new double ( ) ;

9 Dinamikus memóriakezelés Struktúráknak is foglalható memória dinamikusan, amit akár inicializáció is követhet 4 s t r u c t h a l l g a t o { 5 s t r i n g nev ; 6 i n t e l e t k o r ; 7 } ; 10 h a l l g a t o h = { " G i z i ", 19 } ; // L o k a l i s v a l t o z o 11 h a l l g a t o ph1 = new h a l l g a t o ; // Memoria f o g l a l a s 12 ph1 >nev = " Mari " ; // E r t e k a d a s o k 13 ph1 >e l e t k o r = 2 0 ; 14 // Mar l e z e t o s t r u k t u r a v a l i n i c i a l i z a l h a t o 15 h a l l g a t o ph2 = new h a l l g a t o ( h ) ; 16 h a l l g a t o ph3 = new h a l l g a t o ( ph1 ) ; 17 h a l l g a t o ph4 = new h a l l g a t o { " L i l i ", 21 } ; // C++11

10 Dinamikus memóriakezelés Tömböknek is lehet dinamikusan memóriát foglalni 7 c h a r pc = new c h a r [ 1 0 ] ; // Tomb f o g l a l a s a 8 // F u t a s i d o b e n k i s z a m o l t meret sem okoz gondot 9 s r a n d ( t i m e (NULL ) ) ; 10 i n t p i = new i n t [ rand ( ) % 5 0 ] ; 11 d o u b l e pd = new d o u b l e [ ] ; // B e e p i t e t t t i p u s o k b o l a l l o tomb 14 // nem i n i c i a l i z a l h a t o : ( d e l e t e [ ] pc ; // F e l s z a b a d i t a s 17 d e l e t e [ ] p i ; 18 d e l e t e [ ] pd ;

11 Számok rendezése 37 i n t main ( ) { 38 i n t h a s z n a l ; // E n n y i e l e m e t h a s z n a l u n k eppen 39 i n t szamok = new i n t [ OSSZES ] ; 40 c o u t << " Adjon meg n e m n e g a t i v szamokat! \ n" ; 41 b e o l v a s ( szamok, &h a s z n a l ) ; 42 b u b o r e k ( szamok, h a s z n a l ) ; 43 c o u t << " R endezes utan : \ n" ; 44 t o m b K i i r ( szamok, h a s z n a l ) ; 45 d e l e t e [ ] szamok ; 46 r e t u r n 0 ; 47 }

12 Számok rendezése Megjegyzések Javaslat A megoldás nem használta ki, hogy futásid ben is eldönthet a tömb elemszáma A lefoglalt terület felszabadítható, másik is foglalható Foglaljunk valamennyi memóriát a program indulásakor, majd ha elfogyott, mindig növeljük a területet a duplájára! Régi adatokat át kell mozgatni az új helyükre

13 Számok rendezése 49 i n t main ( ) { 50 i n t h a s z n a l ; // E n n y i e l e m e t h a s z n a l u n k eppen 51 i n t szamok ; // Tomb cime 52 c o u t << " Adjon meg n e m n e g a t i v szamokat! \ n" ; 53 szamok = b e o l v a s (& h a s z n a l ) ; 54 b u b o r e k ( szamok, h a s z n a l ) ; 55 c o u t << " R endezes utan : \ n" ; 56 t o m b K i i r ( szamok, h a s z n a l ) ; 57 d e l e t e [ ] szamok ; 58 r e t u r n 0 ; 59 }

14 Számok rendezése 4 i n t b e o l v a s ( i n t h a s z n a l ) { 5 i n t uj, o s s z e s = 1 ; 6 i n t szamok = new i n t [ o s s z e s ] ; 7 h a s z n a l = 0 ; 8 do { 9 c e r r << "\ t [ F e l h a s z n a l v a : " << h a s z n a l 10 << ", tombelemek szama : " << o s s z e s << " ] \ n" ; 11 c o u t << h a s z n a l + 1 << ". szam : " ; c i n >> u j ; 12 i f ( u j >= 0) { 13 i f ( h a s z n a l == o s s z e s ) { 14 c e r r << "\ t [ M e m o r i a f o g l a l a s + mozgatas ] \ n" ; 15 o s s z e s = 2 ; 16 i n t szamok2 = new i n t [ o s s z e s ] ; 17 f o r ( i n t i =0; i < h a s z n a l ; i ++) { 18 szamok2 [ i ] = szamok [ i ] ; 19 }

15 Számok rendezése 20 d e l e t e [ ] szamok ; 21 szamok = szamok2 ; 22 } 23 szamok [ h a s z n a l ] = u j ; 24 ( h a s z n a l )++; 25 } 26 } w h i l e ( u j >= 0 ) ; 27 r e t u r n szamok ; 28 }

16 Számok rendezése Kimenet Adjon meg nemnegativ szamokat! [Felhasznalva: 0, tombelemek szama: 1] 1. szam: 9 [Felhasznalva: 1, tombelemek szama: 1] 2. szam: 8 [Memoriafoglalas + mozgatas] [Felhasznalva: 2, tombelemek szama: 2] 3. szam: 7 [Memoriafoglalas + mozgatas] [Felhasznalva: 3, tombelemek szama: 4] 4. szam: 6 [Felhasznalva: 4, tombelemek szama: 4] 5. szam: 5 [Memoriafoglalas + mozgatas] [Felhasznalva: 5, tombelemek szama: 8] 6. szam: 4 [Felhasznalva: 6, tombelemek szama: 8] 7. szam: 3 [Felhasznalva: 7, tombelemek szama: 8] 8. szam: 2 [Felhasznalva: 8, tombelemek szama: 8] 9. szam: 1 [Memoriafoglalas + mozgatas] [Felhasznalva: 9, tombelemek szama: 16] 10. szam: 0 [Felhasznalva: 10, tombelemek szama: 16] 11. szam: -1 Rendezes utan:

17 Téglalapok rajzolása Alakítsuk ár a téglalap rajzoló programot is hasonlóan, de most mindig ugyanannyival növeljük a tömb méretét, ha elfogy a hely a tömböt lefoglaló és feltölt függvény adja vissza az elemek számát, a tömb címét pedig írja a paraméterként kapott címre! 91 i n t main ( ) { 92 t e g l a l a p t t ; i n t db ; 93 c o u t << " Rajzprogram a d j a meg a t é g l a l a p o k a d a t a i t! \ n" ; 94 db = b e k e r e s (& t t ) ; 95 r a j z o l ( t t, db ) ; 96 d e l e t e [ ] t t ; 97 r e t u r n 0 ; 98 }

18 Téglalapok rajzolása 58 i n t b e k e r e s ( t e g l a l a p t t ) { 59 i n t db=0, o s s z e s = 2, b f x ; 60 b o o l f o l y t a t ; 61 t t = new t e g l a l a p [ o s s z e s ] ; 62 do { 63 c e r r << "\ t [ F e l h a s z n a l v a : " << db << ", elemszam : " 64 << o s s z e s << " ] \ n" ; 65 f o l y t a t = bekerbfx ( db+1, MINX, MAXX 1, &b f x ) ; 66 i f ( f o l y t a t ) { 67 i f ( db == o s s z e s ) { 68 c e r r << "\ t [ M e m o r i a f o g l a l a s + mozgatas ] \ n" ; 69 o s s z e s += 2 ; 70 t e g l a l a p t t 2 = new t e g l a l a p [ o s s z e s ] ; 71 f o r ( i n t i =0; i <db ; i ++) { 72 ( t t 2+i ) = ( ( t t )+ i ) ; 73 }

19 Téglalapok rajzolása 74 d e l e t e [ ] t t ; 75 t t = t t 2 ; 76 } 77 ( t t ) [ db ]. b f. x = b f x ; 78 ( t t ) [ db ]. b f. y = b e k e r ( db+1, "BF s a r o k Y", 79 MINY, MAXY 1); 80 ( t t ) [ db ]. j a. x = b e k e r ( db+1, "JA s a r o k X", 81 ( t t ) [ db ]. b f. x +1, MAXX) ; 82 ( t t ) [ db ]. j a. y = b e k e r ( db+1, "JA s a r o k Y", 83 ( t t ) [ db ]. b f. y +1, MAXY) ; 84 c o u t << db+1 << ". t e g l a l a p r a j z o l ó k a r a k t e r e : " ; 85 c i n >> ( t t ) [ db ]. c ; 86 db++; 87 } 88 } w h i l e ( f o l y t a t ) ; 89 r e t u r n db ; 90 }

20 Téglalapok rajzolása Kimenet 1/2 Rajzprogram - adja meg a téglalapok adatait! [Felhasznalva: 0, elemszam: 2] 1. teglalap BF sarok X: [0, 78] (negativra vege) 0 1. teglalap BF sarok Y[0, 23] 0 1. teglalap JA sarok X[1, 79] 5 1. teglalap JA sarok Y[1, 24] 5 1. teglalap rajzoló karaktere: * [Felhasznalva: 1, elemszam: 2] 2. teglalap BF sarok X: [0, 78] (negativra vege) 2 2. teglalap BF sarok Y[0, 23] 2 2. teglalap JA sarok X[3, 79] 7 2. teglalap JA sarok Y[3, 24] 7 2. teglalap rajzoló karaktere: [Felhasznalva: 2, elemszam: 2] 3. teglalap BF sarok X: [0, 78] (negativra vege) 4 [Memoriafoglalas + mozgatas] 3. teglalap BF sarok Y[0, 23] 4 3. teglalap JA sarok X[5, 79] 9 3. teglalap JA sarok Y[5, 24] 9 3. teglalap rajzoló karaktere: - [Felhasznalva: 3, elemszam: 4] 4. teglalap BF sarok X: [0, 78] (negativra vege) -1 Kimenet 2/2 ****** ****** ** ** ** **

21 C-stílusú karakterláncok A C nyelv karakterláncai C-ben nincs string típus karakteres tömbök tárolják a jelek ASCII kódjait, a lánc végét a 0 kódú karakter ('\0') jelzi Minden eddig látott karakterlánc literál valójában konstans C karakterlánc (tömb) volt! char str[] = "abc"; Automatikusan bekerül a lánczáró karakter a tömb végére! Karakterláncok kezelése: a cstring (string.h) függvényeivel, pl. size_t strlen(const char *s); hossz lekérdezése char *strcat(char *dest, const char *src); összef zés char *strcpy(char *dest, const char *src); másolás A programozó felel ssége, hogy az eredmény elférjen a dest helyen! C++ string C-karakterlánc: string::c_str()

22 C-stílusú karakterláncok 1 #i n c l u d e <i o s t r e a m > 2 #i n c l u d e <s t r i n g > 3 #i n c l u d e <c s t r i n g > // s t r l e n, s t r c o p y, s t r c a t 4 u s i n g namespace s t d ; 5 6 v o i d k i i r ( c o n s t char c s t r ) { 7 c o n s t char ment = c s t r ; 8 c o u t << " ASCII : \ t " ; 9 c s t r ; 10 do { 11 c s t r ++; 12 c o u t << i n t ( c s t r ) << ' \ t ' ; 13 } w h i l e ( c s t r!= ' \0 ' ) ; 14 c o u t << "\ nolv. : \ t " ; 15 f o r ( c s t r=ment ; c s t r!= ' \0 ' ; c s t r ++) { 16 c o u t << c s t r << ' \ t ' ; 17 } 18 c o u t << e n d l ; 19 }

23 C-stílusú karakterláncok 21 i n t main ( ) { 22 k i i r ( "" ) ; 23 k i i r ( "C" ) ; 24 k i i r ( "C s t i l u s " ) ; 25 s t r i n g h = " H e l l o " ; 26 k i i r ( h. c _ s t r ( ) ) ; 27 c h a r v [ ] = " v i l a g! \ n" ; 28 c h a r c s = new c h a r [ h. l e n g t h ( ) + s t r l e n ( v ) + 1 ] ; 29 s t r c p y ( cs, h. c _ s t r ( ) ) ; 30 s t r c a t ( cs, v ) ; 31 c o u t << c s ; 32 d e l e t e [ ] c s ; 33 r e t u r n 0 ; 34 }

24 C-stílusú karakterláncok Kimenet ASCII: 0 Olv.: ASCII: 67 0 Olv.: C ASCII: Olv.: C - s t i l u s ASCII: Olv.: H e l l o Hello vilag!

25 Mátrixok Mátrix: azonos típusú elemek kétdimenziós tömbje A C++-ban csak egydimenziós tömbök léteznek, de ezeket tetsz leges mélységben egymásba lehet ágyazni! mátrix = vektorokból álló vektor A = A[1][2] int A[3][4] = { {11, 12, 13, 14}, {21, 22, 23, 24}, {31, 32, 33, 34} }; m m m A[0] A[1] A[n]... Mátrixok összeadása: (A + B)[i, j] = A[i, j] + B[i, j], ahol A és B két n m méret mátrix.

26 Mátrixok 5 #d e f i n e SOROK 3 6 #d e f i n e OSZLOPOK i n t main ( ) { 9 // d e k l a r a c i o, i n i c i a l i z a c i o 10 i n t a [SOROK ] [ OSZLOPOK] = { 11 { 11, 12, 13, 14 }, 12 { 21, 22, 23, 24 }, 13 { 31, 32, 33, 34 } 14 } ; 15 i n t b [SOROK ] [ OSZLOPOK], c [SOROK ] [ OSZLOPOK ] ; 16 s r a n d ( t i m e (NULL ) ) ; 17 f o r ( i n t s =0; s<sorok; s++) { // mtx. f e l t o l t e s e 18 f o r ( i n t o =0; o<oszlopok ; o++) { 19 b [ s ] [ o ] = 10 + r a n d ()%40; 20 } 21 }

27 Mátrixok 22 f o r ( i n t s =0; s<sorok; s++) { // mtx. ek o s s z e a d a s a 23 f o r ( i n t o =0; o<oszlopok ; o++) { 24 c [ s ] [ o ] = a [ s ] [ o ] + b [ s ] [ o ] ; 25 } 26 } 27 f o r ( i n t s =0; s<sorok; s++) { // m e g j e l e n i t e s 28 f o r ( i n t o =0; o<oszlopok ; o++) { 29 c o u t << a [ s ] [ o ] << ' ' ; 30 } 31 c o u t << ( s==sorok/2? "+ " : " " ) ; 32 f o r ( i n t o =0; o<oszlopok ; o++) { 33 c o u t << b [ s ] [ o ] << ' ' ; 34 } 35 c o u t << ( s==sorok/2? "= " : " " ) ; 36 f o r ( i n t o =0; o<oszlopok ; o++) { 37 c o u t << c [ s ] [ o ] << ' ' ; 38 } 39 c o u t << e n d l ; 40 } 41 r e t u r n 0 ; }

28 Mátrixok Kimenet = Hogyan adható át egy mátrix függvénynek? OK void fv(int t[sorok][oszlopok]) { //... void fv(int t[][oszlopok]) { //... void fv(int (*t)[oszlopok]) { //... Hiba X Ez mutatótömb, nem mátrix! void fv(int *t[oszlopok]) { //...

29 Mátrixok 45 i n t main ( ) { 46 i n t a [SOROK ] [ OSZLOPOK], b [SOROK ] [ OSZLOPOK], 47 c [SOROK ] [ OSZLOPOK ] ; 48 s r a n d ( t i m e (NULL ) ) ; 49 g e n e r a l ( a ) ; 50 g e n e r a l ( b ) ; 51 o s s z e a d ( a, b, c ) ; 52 m e g j e l e n i t ( a, b, c ) ; 53 r e t u r n 0 ; 54 }

30 Mátrixok 5 #d e f i n e SOROK 3 6 #d e f i n e OSZLOPOK v o i d g e n e r a l ( i n t t [ ] [ OSZLOPOK ] ) { 9 f o r ( i n t s =0; s<sorok; s++) { 10 f o r ( i n t o =0; o<oszlopok ; o++) { 11 t [ s ] [ o ] = 10 + r a n d ()%40; 12 } 13 } 14 } v o i d o s s z e a d ( c o n s t i n t ( a ) [ OSZLOPOK], 17 c o n s t i n t ( b ) [ OSZLOPOK], 18 i n t ( c ) [ OSZLOPOK ] ) { 19 f o r ( i n t s =0; s<sorok; s++) { 20 f o r ( i n t o =0; o<oszlopok ; o++) { 21 c [ s ] [ o ] = ( a [ s ] + o ) + ( ( b+s ) + o ) ; 22 } 23 } 24 }

31 Mátrixok 26 v o i d m e g j e l e n i t ( c o n s t i n t a [ ] [ OSZLOPOK], 27 c o n s t i n t b [ ] [ OSZLOPOK], 28 c o n s t i n t c [ ] [ OSZLOPOK ] ) { 29 f o r ( i n t s =0; s<sorok; s++) { 30 f o r ( i n t o =0; o<oszlopok ; o++) { 31 c o u t << a [ s ] [ o ] << ' ' ; 32 } 33 c o u t << ( s==sorok/2? "+ " : " " ) ; 34 f o r ( i n t o =0; o<oszlopok ; o++) { 35 c o u t << b [ s ] [ o ] << ' ' ; 36 } 37 c o u t << ( s==sorok/2? "= " : " " ) ; 38 f o r ( i n t o =0; o<oszlopok ; o++) { 39 c o u t << c [ s ] [ o ] << ' ' ; 40 } 41 c o u t << e n d l ; 42 } 43 }

32 Mátrixok Probléma: rugalmatlan függvények, mert az oszlopok száma rögzített Megoldás: hozzunk létre dinamikusan vektorokat (pl. int*-gal címezhet k), majd ezek címeit tároljuk egy újabb, dinamikus vektorban (int**, mutatótömb)! int** n int* m int A[0] A[0][1] A[n]......

33 Mátrixok 56 i n t main ( ) { 57 s r a n d ( t i m e (NULL ) ) ; 58 i n t s o r o k = 1 + r a n d ()%4; 59 i n t o s z l o p o k = 1 + r a n d ()%4; 60 i n t a = l e f o g l a l ( s o r o k, o s z l o p o k ) ; 61 i n t b = l e f o g l a l ( s o r o k, o s z l o p o k ) ; 62 i n t c = l e f o g l a l ( s o r o k, o s z l o p o k ) ; 63 g e n e r a l ( a, s o r o k, o s z l o p o k ) ; 64 g e n e r a l ( b, s o r o k, o s z l o p o k ) ; 65 o s s z e a d ( a, b, c, s o r o k, o s z l o p o k ) ; 66 m e g j e l e n i t ( a, b, c, s o r o k, o s z l o p o k ) ; 67 f e l s z a b a d i t ( a, s o r o k ) ; 68 f e l s z a b a d i t ( b, s o r o k ) ; 69 f e l s z a b a d i t ( c, s o r o k ) ; 70 r e t u r n 0 ; 71 }

34 Mátrixok 6 i n t l e f o g l a l ( i n t s o r o k, i n t o s z l o p o k ) { 7 i n t t = new i n t [ s o r o k ] ; 8 f o r ( i n t s =0; s<s o r o k ; s++) { 9 t [ s ] = new i n t [ o s z l o p o k ] ; 10 } 11 r e t u r n t ; 12 } v o i d g e n e r a l ( i n t t, i n t s o r o k, i n t o s z l o p o k ) { 15 f o r ( i n t s =0; s<s o r o k ; s++) { 16 f o r ( i n t o =0; o<o s z l o p o k ; o++) { 17 t [ s ] [ o ] = 10 + rand ()%40; 18 } 19 } 20 }

35 Mátrixok 22 v o i d o s s z e a d ( i n t a, i n t b, i n t c, 23 i n t s o r o k, i n t o s z l o p o k ) { 24 f o r ( i n t s =0; s<s o r o k ; s++) { 25 f o r ( i n t o =0; o<o s z l o p o k ; o++) { 26 c [ s ] [ o ] = ( a [ s ] + o ) + ( ( b+s ) + o ) ; 27 } 28 } 29 } 49 v o i d f e l s z a b a d i t ( i n t t, i n t s o r o k ) { 50 f o r ( i n t s =0; s<s o r o k ; s++) { 51 d e l e t e [ ] t [ s ] ; 52 } 53 d e l e t e [ ] t ; 54 }

36 Mátrixok Alternatív megoldás: utánozzuk a statikus tömbök memóriabeli szerkezetét, azaz valójában vektornak foglalunk helyet, és erre képezzük le a mátrix elemeit A[2*sorhossz+1] int* m 0 int n

37 Mátrixok 45 i n t main ( ) { 46 s r a n d ( t i m e (NULL ) ) ; 47 i n t s o r o k = 1 + r a n d ()%4; 48 i n t o s z l o p o k = 1 + r a n d ()%4; 49 i n t a = l e f o g l a l ( s o r o k, o s z l o p o k ) ; 50 i n t b = l e f o g l a l ( s o r o k, o s z l o p o k ) ; 51 i n t c = l e f o g l a l ( s o r o k, o s z l o p o k ) ; 52 g e n e r a l ( a, s o r o k, o s z l o p o k ) ; 53 g e n e r a l ( b, s o r o k, o s z l o p o k ) ; 54 o s s z e a d ( a, b, c, s o r o k, o s z l o p o k ) ; 55 m e g j e l e n i t ( a, b, c, s o r o k, o s z l o p o k ) ; 56 d e l e t e [ ] a ; 57 d e l e t e [ ] b ; 58 d e l e t e [ ] c ; 59 r e t u r n 0 ; 60 }

38 Mátrixok 6 i n t l e f o g l a l ( i n t s o r o k, i n t o s z l o p o k ) { 7 r e t u r n new i n t [ s o r o k o s z l o p o k ] ; 8 } 9 10 v o i d g e n e r a l ( i n t t, i n t s o r o k, i n t o s z l o p o k ) { 11 f o r ( i n t s =0; s<s o r o k ; s++) { 12 f o r ( i n t o =0; o<o s z l o p o k ; o++) { 13 t [ s o s z l o p o k + o ] = 10 + r a nd ()%40; 14 } 15 } 16 } v o i d o s s z e a d ( i n t a, i n t b, i n t c, 19 i n t s o r o k, i n t o s z l o p o k ) { 20 f o r ( i n t s =0; s<s o r o k ; s++) { 21 f o r ( i n t o =0; o<o s z l o p o k ; o++) { 22 c [ s o s z l o p o k+o ] = a [ s o s z l o p o k+o ] + b [ s o s z l o p o k+o ] ; 23 } 24 } 25 }

39 Mátrixok Inline függvények: javaslat a fordítónak, hogy a függvény kódját helyettesítse be minden hívás helyére csak egyszer, rövid függvényekkel javasolt használni függvény hívási id megtakarítható kódméret növekszik 10 i n l i n e i n t i d x ( i n t s, i n t o, i n t o s z l o p o k ) { 11 r e t u r n s o s z l o p o k + o ; 12 } v o i d g e n e r a l ( i n t t, i n t s o r o k, i n t o s z l o p o k ) { 15 f o r ( i n t s =0; s<s o r o k ; s++) { 16 f o r ( i n t o =0; o<o s z l o p o k ; o++) { 17 t [ i d x ( s, o, o s z l o p o k ) ] = 10 + r a n d ()%40; 18 } 19 } 20 }