Újabb vezérlési szerkezetek. Operátorok. Struktúrák

Felülről lefelé tervezés

Szám kiírása adott számrendszerben. Pl. 125_tíz → 1, 2, 5.
A nehézség: balról jobbra kell kiírnunk a számjegyeket.

for (i=SZÁMJEGYEK_SZÁMA…-1; i>=0; i-=1) // ciklus visszafelé
   printf("%c", '0' + N_EDIK_SZÁMJEGY…);

Ha vannak ilyen függvényeink, nem is olyan nehéz!

Függvények

Főprogram, alprogram: a főprogram megáll, amíg az alprogram dolgozik.

• Az alprogramok nevet kapnak: prim()
• Bemenettel, kimenettel rendelkeznek: int prim(int szam);
• Építőkőként használhatóak: if (prim(i)) …

Újabb vezérlési szerkezetek

• A ciklusfeltétel ellenőrzése a ciklusmag után történik
• Emiatt a ciklusmag legalább egyszer végrehajtódik
• Az első végrehajtás a feltételtől függetlenül megtörténik

do 
   utasítás;
while (feltétel);

do {
   utasítások…
} while (feltétel);

A feltétel a kódban is alul van. Ez emlékeztet arra, hogy csak a ciklusmag után ellenőrzi.

Példa: lottósorsolás

int szamok[5];

for (i=0; i<5; i+=1) {  // 5 darab szám kell
   do {
      szamok[i]=rand()%90+1;

      mar_van=0;        // van már ilyen? (lineáris keresés)
      for (j=0; j<i; j+=1)
         if (szamok[j]==szamok[i])
            mar_van=1;
   } while (mar_van);   // ha van, újra!
}

mar_van=1;
while (mar_van) {
   szamok[i]=rand()%90+1;
 
   mar_van=0;         /* nezzuk meg, van-e ilyen */
   for (j=0; j<i; j+=1)
      if (szamok[j]==szamok[i])
         mar_van=1;
}

Működésük

• break: megszakítja a ciklus futását
• continue: a következő iterációval folytatja a ciklust

 while (…) {
     …
     if (…)
┌───   break;
│    …
│}
└>

┌─> while (…) {
│     …
│     if (…)
└───     continue;
      
      …
    }

Használatuk

• Néha áttekinthetőbb a kód
• Általában nem… Csak a ciklust kellene jobban szervezni!
• Ezért próbáljuk kerülni a használatukat!

continue – vigyázat, a for() ciklusnál a következő iteráció azt jelenti, hogy a ciklus fejlécében megadott műveletet, az utótevékenységet még végrehajtja!

Ezek az utasítások nem strukturált vezérlési szerkezeteket eredményeznek. Vagyis nem felelnek meg sem a szekvenciának, sem a ciklusnak, sem az elágazásnak. Csak nagyon indokolt esetben használjuk őket! A break és continue használatára egész félévben gyakorlatilag nem fogunk példát mutatni. Legyen az egész félév összes programja példa inkább arra, hogy nagyon jól meg lehet lenni break és continue nélkül is. És főleg goto nélkül!

Gyakori fordulat

Egy változó lehetséges értékei alapján különféle dolgokat kell csinálni:

1. Adatbevitel
2. Módosítás
3. Kimutatás
…
0. Kilépés

Választás: _

if (valasztott==1) {
   …
} else if (valasztott==2) {
   …
} else {
   …
}

A sorozatos if …; else if … kiváltására használható a switch().

printf("Töröljem a fájlt? (I)gen vagy (n)em? ");
scanf(" %c", &valasz);

switch (valasz) {
   case 'I': /* kis- és nagybetű is jó */
   case 'i':
      printf("Igent válaszoltál, törlöm!\n");
      break;
   
   case 'N':
   case 'n':
      printf("Nemet válaszoltál, meghagyom.\n");
      break;
   
   default:
      printf("Érvénytelen válasz!\n");
      break;
}

switch (kifejezés) { // egész számra kiértékelődő
   case érték1:
   case érték2:      // több is lehet, de konstansok
   case érték3:
      …
      break;
   
   case érték4:
      …
      …              // több utasítás is lehet
      …
      break;
   
   default:          // ha egyik sem (opcionális)
      …
      break;
}

Operátorok

Operátorok

• Kifejezések építőkockái
• Pl. matematikai műveletek: +, -, *, /
• Operandusok: amiken a műveletet végzik
• -x unáris (unary), x-y bináris (binary), azaz egy- és kétoperandusú

Precedenciák: erősségek

• Különfélék között: melyik művelet „erősebb”
• A szorzás „erősebb”, ezért 5+2*3 = 5+(2*3)
• Ha másképp szeretnénk, zárójelezünk

Asszociativitás: mik az operandusok

• Egyformák között: csoportosíthatóság
• Összeadás balra: a+b+c → (a+b)+c
• Értékadás jobbra: a=b=c → a=(b=c).

int a=5, b=2;
double c=5, d=2;
double x;

x = c / d;         // 2.5
printf("%g\n", x);

x = a / b;         // 2
printf("%g\n", x);

x = (double)a / b; // 2.5
printf("%g\n", x);

Polimorfizmus (többalakúság)

Az operátorok jelentése függhet az operandusok típusától:

• a/b: osztás. Ha a és b is int, egész osztás. Ez lefelé kerekít!
• Ha bármelyik lebegőpontos, az eredmény is. Ha kell, a másik automatikusan konvertálódik.

Az egész osztás sok esetben hasznos: például ha az a kérdésünk, hogy 5500 Ft kifizetéséhez hány ezresre van szükségünk. 5500/1000 = 5 darab ezres, és 5500%1000 = 500 Ft a maradék, amelyet máshogy kell megoldanunk, nem ezresekkel.

Automatikus konverzió egyéb esetekben is történik. Pl. short+int összeadás esetén a short típusú operandus a nagyobb ábrázolási tartományú int típusúvá konvertálódik. Ugyanígy, int+long esetén az összeadás előtt az int konvertálódik automatikusan, az 5+2.3 kifejezésben pedig az 5-ből lesz 5.0. Mindig a nagyobb ábrázolási tartomány felé történik az automatikus konverzió, hogy ne amiatt legyen adatvesztés vagy túlcsordulás.

Kézi konverzió (cast)

• Ha két int van, de lebegőpontos osztást szeretnénk, jelezni kell
• Az egyik operandust double-lé alakítva, elé írva: (double)
• Ez a konverziós operátor (cast)

Fontos megfigyelni, hogy a c=a/b kifejezésben az eredmény még így is 2, hogy utána azt egy double típusú változóba másoljuk! Az értékadás egy másik operátor, amelynek az osztás eredményére már nincsen hatása. Az osztás egész/nem egész jellege nem azon múlik, hogy az elvégzése után mit csinálunk az eredménnyel!

A konverzió segítségével más típusúvá alakítható egy érték. Egy lebegőpontos érték elé (int)-et írva egésszé alakítható az, természetesen a törtrészt elveszítve.

Számtani műveletek esetén ritkán kell kézi konverziót alkalmazni. Más típusoknál, a mutatóknál, amelyek egy későbbi előadáson fognak szerepelni, nagyobb szerepet kapnak a konverziók. De ezekről majd később.

Emlékeztető: függvények fő- és mellékhatása

int osszeg(int a, int b)
{
   printf("Összeadom: %d és %d\n", a, b); // mellékhatás
   
   return a+b;                            // főhatás
}

• Főhatás: a függvénynek értéke van
• Mellékhatás: minden egyéb, aminek nyoma van, pl. kiír valamit

Operátoroknál

• Főhatás: a kiértékelés után a kifejezésnek értéke van
• Mellékhatás: történhet más is, pl. megváltozik egy változó értéke

Összeadás, a+b

• Főhatás: az összeg kiszámolódik, mellékhatás: nincs

Értékadás, a=b

• Mellékhatás: b értéke a-ba másolódik
• Főhatás: az egész a=b kifejezés értéke a másolt érték
• A főhatás miatt az értékadás láncolható:

  a=b=1;
  
  a=(b=1);  /* ugyanaz */
  
  b=1; a=b; /* ez is */

  printf("%d", a=b);

  a=b;
  printf("%d", a);

• Balérték=jobbérték (lvalue=rvalue).
  Jobbérték: ami kiértékelhető, balérték: aminek érték adható.

Vegyük észre, hogy a mellékhatással nem rendelkező operátorokkal leírt képletek mindig ugyanazt az eredményt adják! 5*2+4 mindig 14 lesz; míg pl. a+=1-ről ez nem mondható el, hiszen többször egymás után kiértékelve mindig más eredményt kapunk. Az = operátort a mellékhatása miatt használjuk, a főhatásával ritkán törődünk. Az utóbbi viszont lehetővé teszi a láncolt értékadást: pl. az a=b=c=0 kifejezés mindhárom változót nullázza. Akár kifejezőbb is lehet, mint külön leírni mind a három nullázást.

Az értékadás főhatása miatt olyanokat is lehet írni, mint a fenti printf – de nem érdemes. Az ilyesmi csak zavart okoz. Bár a fordító által készített gépi kód úgyis teljesen ugyanaz lesz, inkább kerüljük a felesleges tömörítést! Jobb külön, két sorba leírni a két, egymástól logikailag független teendőt (értékadás, kiírás).

A balérték, jobbérték kifejezéseket ismerni kell, mert a fordító hibaüzeneteiben gyakran megjelennek. Például az 5=6 kifejezésre az „lvalue required as left operand of assignment” jelzést kapjuk, vagyis hogy az értékadás bal operandusaként egy balérték kell szerepeljen. Ugyanígy helytelen emiatt az 5=a kifejezés is.

A fentiek érvényesek az összes kombinált értékadó operátorra is: +=, -=, >>= stb.

#include <stdio.h>

int main()
{
   int a;
   
   a=5;
   printf("előtte: %d\n", a);
   printf("értéke: %d\n", ++a);
   printf("utána: %d\n", a);
   printf("\n\n");

   a=5;
   printf("előtte: %d\n", a);
   printf("értéke: %d\n", a++);
   printf("utána: %d\n", a);
   
   return 0;
}

a=5;

printf("%d", ++a); // 6

a=5;
++a;
printf("%d", a); // 6

a=5;

printf("%d", a++); // 5

a=5;
printf("%d", a); // 5
++a;

Ciklusban vagy önmagában

for (i=0; i<100; ++i)
   …

Nem használjuk a főhatást. Itt mindegy, melyik formát írjuk.

Tömb feltöltése

szamok[db++]=szam_beolvas();

Posztfix: a darabszám régi értéke az index; oda beírjuk, utána növeljük.
Pl. ha db=2, az új elem szamok[2] helyre kerül, utána db=3 lesz.

Ami pont stimmel, hiszen az 5 elem a szamok[0]…szamok[4] helyeken van. Vegyük észre: kényelmes dolog, hogy 0-tól számozódnak a tömbindexek!

A logikai &&, || rövidzár tulajdonsága

Ha a bal oldal alapján eldől az eredmény, a jobb ki sem értékelődik!

• A&&B: ha A=HAMIS, nem számít B, az egész biztosan HAMIS
• A||B: ha A=IGAZ, a kifejezés értéke biztosan IGAZ

if (b!=0 && a/b>3)  // elkerüljük a 0-val osztást!

A jobb oldali rész lehet, hogy nem értékelődik ki – ez problémás lehet akkor, ha olyan kifejezés van ott, aminek van mellékhatása. Pl. if ((x=a/2) && (y=b/2)) kódrészlet: ha a/2 értéke 0, y-ba nem másolódik be b/2. Az ilyen program nagyon nehezen érthető. Lehetőleg kerüljük, ne írjunk ilyeneket! Ne használjunk olyan kifejezést az && és a || operátorok operandusában, amelynek mellékhatása van!

?: feltételes operátor

• Az egyetlen 3 operandusú operátor (ternary operator)
• Formája: feltétel ? igaz_kif : hamis_kif
• Ha a feltétel igaz, akkor a kifejezés értéke igaz_kif
• Ha hamis, akkor pedig hamis_kif

y = x<0 ? -x : x;

nagyobb = a>b ? a : b;

Erre ugyanaz érvényes, mint a fentire. A két kifejezés közül csak az egyik fog kiértékelődni. A másiknak a mellékhatása is elmarad.

Több kifejezésből csinál egyet; értéke az utolsó kifejezés értéke.

• Pl. i=0, j=1 két értékadás, balról jobbra sorrendben
• Leggyakrabban for ciklus fejlécében

  unsigned i, j;
  
  for (i=0, j=1; i<5; i++, j<<=1)  /* erőltetett példa */
     printf("Kettő %u. hatványa: %u\n", i, j);

  Kettő 0. hatványa: 1
  Kettő 1. hatványa: 2
  Kettő 2. hatványa: 4
  Kettő 3. hatványa: 8
  Kettő 4. hatványa: 16
  

• Ne vigyük túlzásba a használatát!

Függvényhívás paraméterei: az nem vessző operátor!

A mellékhatások kiértékelési pontoknál (sequence point) érvényesülnek.

i++ + i++ = ?!

• Utasítás végén: ; vagy }
• if, while, for feltétele után
• Néhány operátornál menet közben: , és ?:
• && és ||: a bal oldal után
• Függvényhívás előtt az összes paraméter kiértékelődik

„A szabvány által nem definiált”

• A kiértékelési pontokon túl a mellékhatások sorrendje kötetlen!
• A függvényparaméterek kiértékelési sorrendje kötetlen
• Ha kell, több sorba töréssel, segédváltozók használatával kényeszeríthetjük a sorrendet.

int a=1;
printf("%d %d", ++a, ++a);

3 3

int a=1;
printf("%d %d", ++a, ++a);

2 1

#include <stdio.h>

int egy()
{
   printf("egy\n");
   return 1;
}

int ketto()
{
   printf("ketto\n");
   return 2;
}

int main()
{
   printf("%d %d\n", egy(), ketto());
   
   return 0;
}

ketto
egy
1 2

/* beolvas egy számot a billentyűzetről */
int beolvas(void);

/* kivonás */
printf("A különbség: %d", beolvas()-beolvas());

a = beolvas();  /* kiértékelési pont! */
b = beolvas();  /* ez is! */
printf("A különbség: %d", a-b);

#include <stdio.h>

int main()
{
    double a=2, b=3, c=5;
    
    printf("%f",  a
                 ---
                 b+c );
    
    return 0;
}

Struktúrák

Racionális számok

┌ a   c ┐   ┌ e   g ┐   ad+cb    eh+gf   (ad+cb)(eh+gf)
  ─ + ─   ·   ─ + ─   = ───── · ───── = ───────────
└ b   d ┘   └ f   h ┘     bd       fh         bdfh

i=(a*d+c*b)*(e*h+g*f);
j=b*d*f*h;

Mi hiányzik nekünk? Az adat absztrakciója!

Tort a, b, c, d; saját típus

Tort osszeg(Tort t1, Tort t2);  saját műveletek
Tort szorzat(Tort t1, Tort t2);

x = szorzat(osszeg(a, b), osszeg(c, d));

Típus: értékkészlet és hozzá tartozó műveletek.

Egyszerű, beépített típusok:

• Egész számok: int, long int stb.
• Lebegőpontos számok: float, double
• Karakterek: char
• Logikai: int

Összetett, származtatott típusok:

• Tömb: tároló; egyforma típusú elemek sorban, sorszámozva
  • Pl. int t[10] → t[0]…t[9], 10 darab egész szám
  • Speciális tömb a sztring: karakterek végjeles sorozata
• Struktúra: összetartozó adatok

Struktúrák: mire jók?

• Új típus létrehozása
• Absztrakt fogalom reprezentációja egyszerűbb, meglévő típusokkal
• Összetartozó adatok egységként!

Pl. két tört számlálója és nevezője struktúra nélkül:

int asz, an, bsz, bn; // a és b tört, számlálók és nevezők

Ehelyett a törteket egységként kezelve, struktúrával:

struct Tort {
   int szaml, nev;  // tört: számláló és nevező
};

struct Tort a, b;   // a és b tört

A változók és típusok elnevezésénél érdemes figyelni a következetességre, mert az megkönnyíti a programok írását és megértését. Sok helyen szabályokat is alkotnak erre, amelyeket egy adott cégnél vagy programozói közösségnél szigorúan betartanak. Egyik ilyen elterjedt szokás az, hogy a saját típusok neveit nagybetűvel kezdik, a változókat pedig kicsivel. Ezért lett a tört struktúra neve a fenti példákban a nagybetűs Tort, az egyes példányok neve pedig a kisbetűs a és b.

struct név { definíció
   T1 mező1, mező2, …;
   T2 mező3;
   …
};

struct Pont {
   double x, y;
};

struct Pont p1, p2;

Az egyes mezők deklarációjának szintaktikája megegyezik a változók deklarációinak szintaktikájával: Típus név;. Csak itt nem változó lesz belőlük, hanem egy struktúra adattagjai lesznek. T1, T2… bármilyen, már létező típusok lehetnek. A struktúra neve is bármi lehet, ami még nem foglalt. Hasonlóan, a mezők különböző nevűek kell legyenek – azonban az megengedett, hogy különböző struktúrák ugyanolyan mezőneveket tartalmazzanak. Pl. a Pont2D struktúra mezői lehetnek x és y, a Pont3D struktúra mezői pedig x, y és z.

Mezőkre (adattagokra) hivatkozás

p pont: (3;6)

struct Pont p;

p.x=3;  // az x koordinátája legyen 3
p.y=6;

printf("p pont: (%f;%f)", p.x, p.y);

A struktúra mezőkből áll, más néven: tagok vagy adattagok (member). Adott mezőre ponttal hivatkozunk: változó.mezőnév. Pl. p.x jelentése: a p pont x koordinátája. Ebben p típusa struct Pont, p.x típusa pedig double. Egy adattag teljesen ugyanúgy tud viselkedni, mint bármelyik másik változó: érték adható neki, kifejezésekben szerepelhet, printf() kiírja, scanf() beolvassa. Sajnos ez utóbbi függvények a struktúrát, mint egészt, nem tudják kezelni.

Értékadás

struct Pont p1, p2;

p1=p2;  // minden mezőt másol: p1.x=p2.x; p1.y=p2.y;

Függvény paramétere, visszatérési értéke

/* megadja a pont origótól mért távolságát */
double origo_tavolsag(struct Pont p)
{
   return sqrt(p.x*p.x + p.y*p.y); // pont típusú paraméterből
}

struct Pont a;
printf("%f", origo_tavolsag(a));

Visszatérési érték is lehet.

Struktúrák inicializálása

struct Pont {
   double x, y;
};

struct Pont p = { 2, 5 };   // inicializálás: p.x→2 és p.y→5

Az egyes értékek a definíció sorrendje szerint meghatározott módon kerülnek a mezőkbe. Vigyázni kell, ha megváltoztatjuk a sorrendet!

Szóhasználat: értékadás != inicializálás

• Inicializálás: a változó definiálásakor a kezdeti értéket is megadjuk
• Értékadás: később új értéket adunk neki
• Ez nem ugyanaz, csak mindkettő jele az = jel!

A typedef kulcsszóval egy típusnak adhatunk új nevet:

typedef int Egesz; // meglévő név és új név
typedef char Betu;

Egesz x;           // x egész, vagyis int
Betu b;

A typedef kulcsszóval egy meglévő típusnak adhatunk egy új nevet. Olyan nevet érdemes adni, amelyik számunkra beszédesebb és jobban kifejezi az adott típus szerepét. Itt is hasonló a szintaktika, mint a változó deklarációjánál: előbb a típus, utána a név. Csak a névből nem változó neve lesz, hanem a típusnak egy másik neve.

Struktúráknál gyakran használjuk:

struct Pont {
   double x, y;
};
typedef struct Pont Pont;

Pont p;

typedef struct Pont {
   double x, y;
} Pont;


Pont p;

Mindkét forma ugyanazt jelenti.

typedef struct {
   double x, y;
} Pont;

A típusokat általában globálisan adjuk meg: mindenhol látszódjanak.

/* globálisan */
typedef struct Tort {
   int szaml, nev;
} Tort;


int fuggveny()
{
   Tort t1, t2; // látható
}

int masik_fuggveny()
{
   Tort b;   // ez is
}

/* lokálisan */
int fuggveny()
{
   typedef struct Tort {
      int szaml, nev;
   } Tort;
   
   Tort t1, t2; // látható
}

/* Ez így HIBÁS! */
int masik_fuggveny()
{
   Tort t;   // ismeretlen!
}

A saját típusainkat definiálhatjuk lokálisan és globálisan. A típusok általában azért globálisak, mert a programunk adatai azokon belül több helyen is előkerülnek. Vagyis több függvényben is. Ennek ellenére természetesen lehetséges az, hogy egy adott típus csak egy függvényen belül létezik. Ha csak ott használjuk, akkor érdemes lokálisan megadni, mert akkor követhetőbb a program mások számára.

Racionális számok

Feladat: a C nyelv nem tartalmaz tört típust. Hozzunk létre egyet! Írjuk meg az ezeket összeadni, szorozni, kiírni tudó programrészeket!

Megoldás

• Ez új típus! Saját értékkészlet és műveletek!
• Összetartozó adatok is. Ezért ez egy struktúra lesz!
  
• A műveletek pedig függvények.

Struktúra Kiírás Valós érték Összeadás

Teszt Egyszerűsítés Műveletek Beolvasás

typedef struct Tort { // függvényen kívül: globális
   int szaml, nev;
} Tort;

int main()
{
   Tort t1;           // a typedef miatt elég annyi, hogy Tort
   
   t1.szaml=1;        // 1/2
   t1.nev=2;
   
   return 0;
}

Tort t1;

t1.szaml=2;
t1.nev=3;
tort_kiir(t1); // 2/3 jelenjen meg

/* Kiírja a törtet számláló/nevező alakban */
void tort_kiir(Tort t)
{
   printf("%d/%d", t.szaml, t.nev);
}

Tort x={2, 3};

printf("%f\n", tort_valos(x)); // 0.666667

/* Visszatér a tört lebegőpontos értékével */
double tort_valos(Tort t)
{
   return (double)t.szaml / t.nev;
}

osszeg=tort_osszead(a, b);

a   c    ad+cb
─ + ─ = ─────
b   d      bd 

/* visszatér a két tört összegével */
Tort tort_osszead(Tort t1, Tort t2)
{
   Tort uj;
   
   uj.szaml=t1.szaml*t2.nev + t2.szaml*t1.nev;
   uj.nev=t1.nev*t2.nev;
   
   return uj;
}

Törtek összeadása – eredmény?!

Itt tartunk most:

#include <stdio.h>

typedef struct Tort {
   int szaml, nev;
} Tort;

void tort_kiir(Tort t);
Tort tort_osszead(Tort t1, Tort t2);

int main()
{
   Tort x={1, 2}, y={1, 4};
   
   tort_kiir(tort_osszead(x, y));
   
   return 0;
}

void tort_kiir(Tort t)
{
   printf("%d/%d", t.szaml, t.nev);
}

Tort tort_osszead(Tort t1, Tort t2)
{
   Tort uj;
   
   uj.szaml=t1.szaml*t2.nev
           +t2.szaml*t1.nev;
   uj.nev=t1.nev*t2.nev;
   
   return uj;
}

6/8

x=tort_letrehoz(50, 100); // 1/2

/* Törtet hoz létre, egyszerűsítve */
Tort tort_letrehoz(int szaml, int nev)
{
   Tort uj;
   int a=szaml, b=nev;

   while (b!=0) {      // Euklidész
      int t=b; b=a%b; a=t;
   }
   uj.szaml=szaml/a;
   uj.nev=nev/a;   // legnagyobb közös osztó = a
   return uj;
}

/* műveletek törtekkel */
osszeg=tort_osszead(a, b);
szorzat=tort_szoroz(a, b);

/* Visszatér a törtek összegével. */
Tort tort_osszead(Tort t1, Tort t2)
{
   return tort_letrehoz(t1.szaml*t2.nev + t2.szaml*t1.nev,
                        t1.nev*t2.nev);
}

a c   ac
─·─ = ──
b d   bd

/* Visszatér a törtek szorzatával. */
Tort tort_szoroz(Tort t1, Tort t2)
{
   return tort_letrehoz(t1.szaml*t2.szaml,
                        t1.nev*t2.nev);
}

Írd be a törtet:
6/8_

Tort t;

t=tort_beolvas();

/* beolvas egy törtet a billentyűzetről, és visszaadja */
Tort tort_beolvas(void)
{
   int szam, nev;
   scanf("%d / %d", &szam, &nev);
   return tort_letrehoz(szam, nev);
}

int siker_db;
double szam;

siker_db=scanf("%lf", &szam);

(Többszörösen) összetett adatok

Struktúrába egy dolog összetartozó adatait tesszük.

• Különálló, új típus!
• Ezekhez műveletek is tartoznak
• Pl. egy könyv adatai: cím, szerző, oldalszám

Tömbben több egyforma dolog adatait tároljuk.

• Ez csak egy tároló.
• Egy tömbbe kerülő dolgoknak nem feltétlenül van közük egymáshoz!
• Pl. számok sorozata, névsor, könyvek katalógusa

Elfajulások lehetségesek. Létezhet egy elemű struktúra vagy tömb is. Alma, körte, az, a: ezek szavak, még az „a” is, hiába egy betűs!

struct Pont10D {
   int x, y, z, a, b, c, d, e, f, g; // struktúra ennyi névvel?
};

int koord[10];                       // vagy inkább tömb?

struct Pont10D {
   int koord[10];   // így lehet értékül és paraméterként adni
};

Szövegek reprezentálása

• A szöveg: sztring (string), karakterek sorozata
• C-ben nincs külön típus, hanem karakterek tömbjeként adják meg
• Röviden:

char str[100]="hello";

printf("A szöveg: [%s].", str); // A szöveg: [hello].

Mivel a sztring a C-ben karaktertömb, a méretét meg kell mondanunk előre. Az = értékadás operátor sem használható rajta. Következő előadáson részletesen szerepelni fog.

A kétdimenziós tömb többszörösen összetett: tömbök tömbje.

5 sor × 6 oszlop

double matrix[5][6];

3×3 játéktér

char amoba[3][3];

palya[0][2]='o';

Többszörösen összetett adatok esetén a definíciók sorrendjére figyelni kell: csak a már definiált típusokból lehet építkezni.

struct Datum { int ev, honap, nap; };
struct Ember {
   char nev[100];         // struktúrában tömb
   char lakcim[150];
   struct Datum szuletes; // struktúrában struktúra
};

A typedef itt jól használható:

typedef struct Pont { int x, y; } Pont;
typedef Pont Hatszog[6];             // Pontokból álló tömb
Hatszog h;

Típusok:

typedef struct Pont {      // egy pont a síkban
   double x, y;
} Pont;

typedef struct Szakasz {
   Pont eleje, vege;       // szakasz két pont között
} Szakasz;

typedef struct Kor {       // középpont és sugár
   Pont kozeppont;
   double sugar;
} Kor;

Művelet példa:

/* igazzal tér vissza, ha egy pontban metszik egymást */
int metszi_e(Szakasz sz1, Szakasz sz2);