Na úgy gondoltam, hogy továbbra is lehet még a dinamikus memóriakezeléssel foglalkozni, feltéve, ha elmagyarázom elôbb a struktúrákat. Akkor meg már jöhetnek az enum-ok,union-ok,bit field-ek class-ok stb. Adajj!

 

Tehát struktúra (struct):

A struct egy olyan bizé, mint pascalban a record. A record pedig egy olyan bigyó, amelynek több mezôje van. Például el akarjuk tárolni barátainkról, hogy mikor születtek (/fognak megpurcanni (vajon honnan tudjuk(:!)). Csinálunk egy olyan struktúrát, amelynek van egy olyan mezôje, hogy név , meg egy olyan, hogy dátum(ev,honap,nap). pl.:

 

struct smyfriends

{
char nev[20];
int ev;
int honap;
int nap;

} myfriends[100]; //feltéve, hogy 100 baratunk van

 

Ilyen egyszerű. Az smyfriends a struktúra neve, a myfriends, pedig a változóé(esetünkben tömb). A struktúra nevét nem kötelezô kiírni, ha biztos vagyunk benne, hogy nincs már szükségünk ilyen típusú változóra. Ugyanis, ha egy struktúrát egyszer már nevével együtt megadtunk, hivatkozhatunk is rá. pl.:

struct smyfriends myenemies[100];
 

Az elôbb már leírtuk a struktúrát, így csak a nevét kellett megadni, meg azt, hogy struct, és máris van egy ugyanolyan típusú változónk, mint az elôbb. Ebbôl következik, hogy a struktúra leírásánál nem kötelezô megadni rögtön változónevet is, hiszen ugyanígy bármikor csinálhatunk ilyen típusú változókat.

 

A struktúra mezôjére ponttal hivatkozunk. pl.:

strcpy(smyfriends[0].nev,"JAKAB");
smyfriends[0].ev=1977;
smyfriends[0].honap=9;
smyfriends[0].nap=29;

Kivéve, ha egy pointerrel hivatkozunk rá, mert ilyenkor -> (mínusz jel után egy kacsacsôr)-el. pl.:

struct myfriends *valaki;

.
.
.
strcpy(valaki->nev,"Jakab");
valaki->ev=1977;
valaki->honap=9;
valaki->nap=29;
 
Természetesen ha a pointert eggyel növeljük, (valaki++;) valójában az egész struktúra méretével nôl, így a következô elemre fog mutatni.

Nézzük az union-okat:

A union hasonló a struktúrákhoz, azzal az igen lényeges különbséggel, hogy a mezôk a memóriában ugyanazon a címen kezdôdnek. Elsô hallásra baromságnak hangzik. Miért jó az nekünk, ha az elemek felülírják egymást a memóriában? Gondoljunk például a regiszterekre. Egy 16 bites regiszter felsô 8 bitjét, vagy alsó 8 bitjét ,vagy akár a 16 bitjét külön kezelhetjük, úgy, hogy az egész regiszter értéke változik.

pl.:

 

union plreg
{
  struct {char al,ah;} b;
  int w;
} axreg;

 

Ennyi a union megadása. Amint látszik, az egyik eleme egy 2 byte-ból álló struktúra, a másik eleme pedig egy word. a két elem ugyanott van a memóriában, tehát, ha az al-be 255 teszünk, a w-ben is 255 lesz.stb.
 

pl.:

axreg.b.al=0xFF;
axreg.b.ah=0xFF;
ugyanaz, mint axreg.w=0xFFFF;
 

Persze ebben a példában a union két eleme ugyanolyan hosszú (2 byte). Ez nem feltétel. Például egy long-ot kezelhetünk egyszer longként, egyszer pedig az alsó bytját külön. A lehetôségek száma végtelen.

 

Enum-ok

Az enum egy olyan egész tipusú változó amely csak egy általunk meghatározott értékhalmazból vehet fel értéket. Például, az, hogy milyen hónap van, kezelhetjük egy int változóval. Ekkor a változó értéke 0 t-ol 1-ig vehet fel értéket. (0=január 1=február...) De sokkal elegnáncsabb enum-al:

 
enum emonths
{
january,february,march,april,jun,july,august,september,october,november,december;
} month;
 

Megadása hasonló, mint a struktúrának, vagy a unionnak, de semmi köze hozzá. Az enum lényege, hogy a változó igazi, fizikai értéke nem érdekel minket, csak a szimbolikus étéke. A változó értéke, csak a felsorolt értékhalmazból vehet fel értéket(a hónapok). Hasonló, mintha, definiáltunk volna minden hónaphoz egy konstansot.

 

switch(mont)
{
case january: ...
case february: ...
.
.
.
}
 

Kezelni pedig ilyen egyszerű.

Azért olyan sok mindenre nem lehet használni. Ha például ki akarjuk íratni:

printf("%d",month);

Csak számként tudjuk kiírni.

Mer azér van igazi értéke is. Ha nem kavarunk bele, az elsô szimbólum 0 a második 1 és így tovább. De megadhatunk ettôl külöbözôeket is. pl:

 

enum emonths
{
january=1,february,march,april,jun,july,august,september,october,november,december;
} month;

 

Tehát fizikailag a január 1-et fog jelenteni. A következô elem 2-t, és így tovább.

 

Bit field-ek:

A bit field-ek olyanok, mint a struktúrák, egyetlen különbség, hogy a struktúra elemei egy word, vagy egy byte bitjeit jelképezik. pl.:

 

struct
{
char bit1  :1;
char tobbi :7;
} bit_var;
 

Ekkor a byte elsô egy bitjét külön tudjuk kezelni, a többit pedig együtt; pl.:
 

bit_var.bit1=0;
bit_var.tobbi=64;

Ennek analógiájára word-oket is kezelhetünk:

struct
{
char bit1 :1;
char bit2 :1;
char tobbi : 14;
} bit_var;

 
Ilyen egyszerű.

A biteknek külön való kezelésére fôleg a hardwerközeli programozásban lesz szükségünk.

 
Class-ok:

A classok hasonlók mint az objektumok, használatuk az objektumorientált programozásban szükségelt. Majd egyszer talán erre is sort kerítünk.