Függvények
Rögtön az elején egy programozás-technikai kérdés:
Van-e eljárás? Nincs?
Vagy mégis?
A megoldást a kimeneti típus nélküli függvények adják. Ezeknél
a return ..; utasítás minden további következmény nélkül
egyhagyhatü. Pl.:
prototípusa:
void kiir(int szam1, int szam2);

Függvény általános alakja (új):

    <visszatérési típus> függvénynév(<param.dekl. lista>)
    {
         <lokális definiciók,deklarációk>
         <utasítás>
    }

    visszatérés lehet bármilyen skalár, vagy struktúra
(esetleg union)
         (minden kiértékelési ágban el 'kell' helyezni, de nem
    muszáj)

    függvény paraméterei
        - új és régi forma


Függvény deklarációja

deklaráció
        csak függvény név és visszatérési érték


prototípus
        teljes(paraméterdekl. lista is)

        int proba(int, int); == int proba(int x, int y);
        de
        int proba2(void); != int proba2();

Többször is megjelenhet a kódban, azonban ezeknek meg kell
egyezniük.


Függvények visszatérési típusa
Típus bármely skalár (standard típusok + felsorolási és mutató
típus), struktúra.
Ha expliciten nem határozzuk a visszatérési típust, akkor
automatikusan az int típusú lesz a függvényérték. Visszatérési
érték nélküli függvényt void típus felhasználásával
készíthetünk, ezáltal eljárás jellegű függvényt hozunk létre.

Függvényattribútumok használata
A visszatérési típus után adhatjuk meg az attribútumokat,
amelyek a függvény alapértelmezett működését módosítják. Ezek a
következők:
 attribútum                        leírás
pascal        Pascal függvényhívási konvenciók használata
cdecl         C függvényhívási konvenciók használata
interrupt     megszakítás-kezelő függvény
near          közeli függvényhívás                  assembly
                                                  függvényekhe
                                                        z
far           távoli függvényhívás                
huge          távoli függvényhívás, az            
              adatszegmens átadásával


Függvény hívás

kif1(<kif2>);
például:
int fgv(int x, double y); // prototípusú függvény esetén:
…
int eredmeny;

eredmeny = fgv(1,2.5);


Változók átadása függvénynek
  ·   érték szerinti átadás
       o   másolatot kap a függvény
o   nem hat vissza az eredetire
o   pl.:
…
int szamol(int x, int y);
…
void main()
{
   int eredmeny, valtozo_1 = 10, valtozo_2 = 30;

   eredmeny = szamol(valtozo_1, valtozo_2);
}

int szamol(int x, int y)
{
   x  += y;

   return x;
}
              Mit is látunk itt:
                  az átadott x értéket módosítjuk az
                    argumentumlista másik elemének értékével,
                    majd a visszatérési értékben visszaadjuk
                    ezt a módosított értéket
                  értékeljük a változók tartalmát:
                   - az eredmeny a két érték összege lesz
                   - a valtozo_1 értéke nem változik ugyanis a
                    függvény meghívásakor a változó értéke
                    átmásolódik a függvény memóriaterületére,
                    és ott módosul az utasítások nyomán; a
                    függvényt elhagyva a változó
                    (memóriaterület) megszünik, így a módosítás
                    nem hat vissza.
  ·   cím szerinti átadás
       o   címet ad át
o   indirekt hivatkozást ad át
o   a memória terület tartalma megváltozhat
            §   pl.: pointer
       o   példa:
void szamol(int *, int *);
void main()
{
   int i, j;
   …
   szamol(&i,&j);
   …
}

void szamol(int* x, int* y)
{
   *x  += 3;
   *y -= 5;
}


Függvények tömbje

int (*fgvek[4]) (int,int) = {fg1,fg2};
int fg1(int,int);
eredm = (*fgvek[1])(x,y);


Struktúrák, tömbök átadása függvénynek

Struktúra átadása
Argumentumként akár érték szerinti, akár mutató segítségével
átadhatjuk függvényeinknek a saját magunk által létrehozott
változókat. A lehetőségek közül a pillanatnyi helyzetet
értékelve kell dönteni; a memóriaigény, teljesítmény
szempontjából a pointer átadása a hatékonyabb. Emellett a
választást a változók blokk elhagyása utáni érvényessége is
befolyásolja (a mutató címet hordoz, így a memóriaterületen
történi változás; lásd feljebb).
A struktúra létrehozása nem befolyásolja a használatot, vagyis
típust létrehozva, és struktúrát definiálva is használhatjuk
őket:
pl.:
   struct ember
   {
       char* nev;
       int eletkor;
   };

   1.  typedef struct ember emberek;
// gyakorlatilag szinonímát készítünk a struktúrához
       int eletkor_kulonbseg(emberek Aladar, emberek Elek)
       {
           int kulonbseg;
           kulonbseg = Aladar.eletkor – Elek.eletkor;
           return kulonbseg;
}

   2.  int eletkor_kulonbseg(struct ember Aladar, struct ember
Elek)
       {
           int kulonbseg;
           kulonbseg = Aladar.eletkor – Elek.eletkor;
           return kulonbseg;
}


Tömbök átadása
Sajnos meg kell különböztetnünk az egy- és kétdimenziós
(esetleg több) eseteket, ezeket külön tárgyaljuk.

Vektor
Bármely vektor átadásnál nem maga a vektor, hanem az első
elemére mutató pointer kerül át a függvényhez (mutató – tömb
analógia), ennek megfelelően érték szerinti átadás ebben az
esetben nincs, amely magával hozza, hogy bármilyen változtatás
a függvényblokk elhagyása után is érvényben marad.
Ezt a const típusminősítővel korlátozhatjuk, vagyis a mutatott
objektum értéke nem változhat meg. Figyeljünk oda a
használatára!
Ennek megfelelően az átadott tömb (mutató) elemszámát nem
ismerjük, ezt általában külön argumentumként adjuk át. Kivételt
képeznek a karaktertömbök, mert ezek tartalmazzák a 0 byte-ot,
így a végét könnyen determinálhatjuk.
pl.:
int p[10];

void fgv(int *pointer, int n)
void fgv(int pointer[], int n) // a két feljéc ekvivalens
egymással, mindkettő csupán a típusát hatáozza meg.
{
   int i,
   for(i=0;i<n;i++)
       p[i];
}

Segítség lehet egy struktúratípust definiálása, amely
tartalmazza a mutatót és a méretét, mint egy-egy adatmező.

Kétdimenziós tömb
Itt is a terület kezdőcímére mutató pointerként értelmezi a
fordító az átadott mátrixok, azonban a sorok elemszámát
figyelembe veszi, az offset meghatározásához. Ennek megfelelően
már csak a sorok számát kell külön argumentumként
rendelkezésére bocsátani.

void fgv(int p[][konkrét szám], int m)
{
   int i, j;
   for(i=0;i<m;i++)
       for(j=0;j<’konkrét szám’;j++)
           printf(„%i”,p[i][j]);
}
Az előbb használt ’konkrét szám’ elhagyását azonban ebben a
formában nem hagyhatjuk el. Ennek a problémának a megoldását
(tetszőleges méretű 2D tömb átadása) egy „1D” mutató és a két
dimenzió argumentumkénti átadása jelenti a következőképp:

void fgv(int *p, int m, int n)
{
   int i, j;
   for(i=0;i<m;i++)
       for(j=0;j<n;j++)
           p[i*m+j];
}


Függvényszerű makrók készítése (lásd még 11. oldal)
definíciója:
#define azonosító(paraméterlista) (helyettesítendő szöveg)
hívása:
azonosító(argumentumlista)

Main függvény
Legegyszerűbb alakja:
void main()
{
...

}

program futásának helyességének ellenőrzéséhez, pl.:

int main()
{
   return 0;   vagy    return 1;
}

…, de...
int main(int argc, char *argv[])
{

}
alakban a program paraméterlistájának feldolgozására is
alkalmas lesz, ahol az argv stringtömb, vagyis a programnév és
a megadott paraméterek tömbje. Az argv[0] jelenti a program
nevét. A másik paraméterünk (argc) a lista hosszát jelenti,
amely mindig 1, hisz a program nevét mindig megkapjuk. A
választott nevek nem kötelezőek, de konvenció szerintiek, tehát
eltérni tőlük (argc, argv) nem érdemes.

program indítás, például:
progi.exe egy Kiss János 35
 argc = 5; argv[0] = progi.exe;, …, argv[2] = Kiss;
A stringtömb elemeit nyilvánvalóan valamilyen ciklussal érdemes
kinyerni; vizsgálathoz pedig az argc tökéletes (megfelelő számú
paramétert adtak-e meg).

pl.:
…
int main(int argc, char *argv[])
{
   int i;
   if(argc != 4)
       printf(„Hibás! Csak %d argumentumot adott meg!\n”,argc);
   else
       for(i = 0; i < argc; i++)
           printf(„%d. argumentum: %s”, i, argv[i]);

   return 1;
}
…

…és DOS-ban használható még a következő formában:

int main(int argc, char *argv[], char **envp)
{
   char** penvp;
   …
   penvp = envp;
   printf(„Környezeti változók:”);
   while(*penvp)
       printf(„ - %s\n”,*penvp++);
   …
}
ahol a kétszeres indirekciójú mutató (char** envp) a környezeti
változók stringtömbje; a név itt is konvenció.

Ami kimarad

Rekurzív függvények

Változó hosszúságú argumentumlista

Tárolási osztályok

Sajnos a változók használata nem olyan kézenfekvő, mint első
ránézésre hinnénk. Leginkább a fordító számára lényeges, hogy a
megadott azonosítók és a memóriában tárolt objektumok között
megfeleltetéseket tudjon tenni. Ehhez a következő feltételek
szükségesek:
  1.  típussal kell rendelkeznie az azonosítónak; célja: memória
     lefoglalt mérete, tárolt érték értelmezése
2.  tárolási osztállyal kell meghatározni, hogy az objektum
hol jön létre a memóriában (regiszter, statikus, dinamikus
terület), milyen élettartammal bír az azonosító.
A tárolási osztályok a következők lehetnek: auto, register,
static, extern. Ha explicit módon nem határozzuk meg az
azonosító tárolási osztályát, akkor a fordító veszi a
fáradságot, és igyekszik meghatározni a forrásban elfoglalt
helye szerint.


Néhány tisztázandó fogalom
Mielőtt a tárolási osztályokat áttekintenénk szükséges átvenni
néhány ide kapcsolódó fogalmat. A magyarázat során a tárolási
osztályok neve fel-felbukkan. Ez ne zavarjon senkit, a
kapcsolat a fontos ezen a ponton (magyarázatok később).

Élettartam
Ez olyan időintervallum, ahol a változó vagy függvény a program
futása során létezik. Ezeket a következőképp csoportosíthatjuk:

Globális (statikus)
Ide tartoznak a static és extern tárolási osztállyal rendelkező
azonosítók. Így az összes függvény valamint minden külső
definiáltságú azonosító globális élettartamú. Tehát a globális
élettartamú azonosító memóriaterülete a program futása során
végig megmarad. Ez azonban nem jelenti azt automatikusan, hogy
az azonosító végig elérhető, mert ezt más körülmény is
befolyásolja (statikus lokális változó is ilyen). Az
inicializálás minden esetben csak egyszer történik meg.

Automatikus (lokális)
Függvényeken, blokkokon belül definiált összes azonosító, amely
nem rendelkezik a static tárolási osztállyal ebbe a kategóriába
esik. Ide tartozik a függvényben deklarált kapcsolódás nélküli
azonosító, és a függvény paraméterhalmaza is. A memóriaterület
és az abban tárolt érték csak a blokkban létezik. Minden
esetben létrejön, ha a függvénybe, blokkba kerülünk, így mindig
újrainicializálódik is. Megjegyzendő, hogy egy blokkban
használt egy globális azonosítóval megegyező nevű azonosító
felülértelmezi a blokkon belül (de csak itt) a globális
azonosítót.

Dinamikus
Felhasználó által, könyvtári függvényekkel foglalt terület.


Érvényességi tartomány, láthatóság
A két fogalom összetartozik: az azonosító csak az érvényességi
tartományában látható. Az érvényességi tartomány a programban
azt a részt jelenti, amely határain belül az azonosító
felhasználható az objektum elérésére (az objektum itt általános
érvényű kategória).
Érvényességi tartmány fajtái:
blokk szintű
Egy meghatározott blokkban deklarált változóra igaz.
Érvényessége a blokkot lezáró }-ig tart.

file szintű
Abban a fordítási egységben érvényes, amelyben deklaráltuk
(lásd több modulból felépülő programok). Más fordítási
egységben (file-ban) definiált azonosítót az extern tárolási
osztállyal tehetjük érvényessé. Ide tartozik, hogy a függvények
mindig külső objektumként viselkednek, ennek következménye,
hogy a definíciójuk nem ágyazható egymásba.

függvény szintű
Ennek a kategóriának a képviselőivel nem bővelkedünk: csak az
utasításcímke tartozik ide.

Még ide kívánkozik, hogy a prototípusban használt változók
blokkhatárolója a ; vagyis a további működést nem határozzák
meg (ezért sem kell nevet adni a paraméterlista elemeinek).


Kapcsolódás
Szorosan kapcsolódik az érvényességi tartomány fogalmához. Az
azonosító nevek különböző érvényességi tartományokban különböző
azonosítókat jelölhetnek, azonban a különböző érvényességi
tartományban deklarált, illetve az azonos érvényességi
tartományban egynél többször deklarált azonosító nevek a
kapcsolódás mechanizmusát kihasználva ugyanarra az objektumra
vagy függvényre hivatkozhatnak. A kapcsolódás jelöli ki azt a
programrészt, ahol az azonosítóra hivatkozhatunk. Így a
következőket különböztetjük meg:
belső kapcsolódású
egyetlen fordítási egységben ismertek. A függvényeket, vagy
globális változókat (file szintű érvényességi körrel rendelkező
objektumok) a static tárolási osztállyal tehetjük belső
kapcsolódásúvá, vagyis más modulból nem érhetők el.
külső kapcsolódású
több modulban megjelenhetnek. Ide tartoznak azok a globális
objektumok vagy függvények azonosítói, amelyek nem tartalmaznak
deklarációjukban tárolási osztályt, vagy az extern tárolási
osztály szerepel.
kapcsolódás nélküli
azon azonosítók, amelyek nem endelkeznek állandó
memóriaterülettel. Ilyenek:
  -   olyan azonosító, amely nem objektumok jelöl (struktúra
     adattag, struktúra neve, enum konstans, címke,…)
-   függvény paraméterek
-   olyan blokk érvényességű objektumok, amelyek
deklarációjukban nem tartalmazzák az extern kulcsszót.

Névterületek
A fordító az azonosítók neveit un. névterületeken tárolja
(felhasználás formájától függően). Azonos névterületek azonos
név nem szerepelhet. Itt különbséget kell tenni az érvényesség
és a névterület konzisztenciája között: azonos érvényességi
tartományon belül lehet azonos neveket használni, ha nem azonos
névterületre esnek, ezáltal különböző azonosítókat képviselnek.
A fordító által elhatárolt névterület típusok:
utasításcímkék:
névvel ellátott utasításcímke, amelyek : követ, része az
utasításnak. A különböző függvényeken belül azonos névvel
jelölhetők
pl.:
void fgv(void)
{
   …
   goto end;
   …
   end:
       printf(„Vége!”);
}
struktúra, unió, felsorolás nevek
struct, union, enum után álló nevek. Ezeknek azonos láthatóság
mellett különbözniük kell.
struktúra, unió adattagjai
a struktúra (unió) névterületén helyezkednek el, ezért több
struktúrában (unióban) azonos nevű adattagok használhatók.
közönséges nevek
minden más azonos névterületen található
típusnevek
azonosító és (saját) típus nem használhatja ua.-t a nevet egy
érvényességi tartományban.


Tárolási osztályok használata

Auto osztály
Tipikusan a blokkon belül definiált változók tartoznak ide.
Létezésük a függvény meghívásához kötődik, amely a
függvényblokkból való kilépésig tart.

Extern osztály
Ide tartoznak a függvényeken kívül definiált változók és maguk
a függvények nevei. Amelyek a definícióban explicit módon nem
adnak meg tárolási osztályt, akkor extern típusúak lesznek. Az
extern változók és függvények élettartama a programba való
belépéstől a program kilépéséig tart. Azonban a láthatóság némi
problémát vet fel.
A külső változókat, függvényeket láthatóvá kell tennünk
deklarációval, vagy prototípus készítésével, ugyanis a függvény
érvényességi tartománya a definíció helyétől a file végéig
terjed, ellenben egy prototípus a teljes file-ra kiterjeszti
ezt („…bizony mondom Néktek,” ezért kell deklarálni!).
Itt lép be az előfordító a képbe (#include), mivel a külső
neveket előszeretettel egy másik un. fejléc állományban
tároljuk el, és a program elején egy direktívával a fordító
figyelmébe helyezzük.
pl.:
#include „myprog.h”

Nyilván megtalálhatjuk az értelmét ezek használatának. Némiképp
automatizmusként használják a programozók a globális
változókat, vagyis közös használatú adathalmazt, hogy több
különböző függvény esetén, amely ugyanazt a halmazt használja
ne kelljen elbonyolítani paraméterlistával. A használatára
ügyelni kell, mert a változó értékében változást eszközölünk.

Az extern eddig tárgyalt alkalmazási köre a static tárolási
osztállyal is megvalósítható. Egyértelmű előnyét több modulból
álló programok esetén használhatjuk ki.

Static osztály
Külső és belső szintű azonosítókkal együtt használható.
Külső szintű azonosító esetében a láthatóságot a file-ra
korlátozza.
Ha belső szintű azonosítókkal használjuk, akkor az élettartamát
automatikusról globálisra módosíthatjuk. Ezáltal a kulcsszó
moduláris programozás esetében az információ elrejtés eszköze
lehet.
A másik használati terület a statikus belső szintű változók
használata. Ezzel azt érjük el, hogy egy blokkra korlátozott
változó nem inicializálódik minden blokkba való belépéskor, és
nem törlődik kilépéskor, vagyis a program indításától a
kilépésig él az azonosító, viszont csak a blokkban érvényes.

Register osztály
belső szintű azonosítók
gyors elérésű azonosítók (ált. változók)
ha van hely a regiszterbe kerül, ellenkező esetben auto lesz.

Az előfeldolgozó
A tárgykód elkészítéséig hosszú út vezet, amely először az
előfeldolgozón megy keresztül, amely a futtatható kód
fordítására alkalmas szöveget hozza létre.
Az előfeldolgozó használata azonban néhány követelményt
támaszt, amelyeket érdemes betartani, hiszen gyakran használjuk
őket, ha csak az #include direktívára gondolunk is. Tehát:
  ·   kötött formában kell megírni:
       o   egy sorba csak egy utasítás kerülhet
o   a parancs nem kerülhet át másik sorba, hacsak nem jelöljük
ki a folytatást
  ·   minden elvégzett művelet csupán szövegkezelés, így
     független attól, hogy a C nyelv kulcsszavai, kifejezései vagy
     változói szerepelnek-e benn.


File-ok beépítése
#include <filenév> vagy #include „filenév”

Makrók használata
#define – foglalás
#undef – feloldás
A használandó azonosítók – konvenció szerint – csupa
nagybetűvel írandóak. Az előfeldolgozó a forrás átvizsgálásakor
lecseréli a makró nevet a helyettesítendő szöveggel.

Objektumszerű makrók készítése
Ekkor az előbb látott direktíva egyszerűbb alakját használjuk:
             #define azonosító helyettesítő szöveg
pl.:
#define NEV        „János”
#define TRUE       1
#define FALSE  0
#define BOOL       int
stb.

Függvényszerű makrók készítése
Ezek az úgynevezett paraméterezett makrók.
Általános definíciója:
#define azonosito(param_lista) (helyettesitendo_szoveg)
A makró meghívása:
azonosito(argumentumlista)
Nyilvánvalóan a paraméterlista és argumentumlista elemszámának
meg kell egyezni, ezzel együtt is készíthető paraméter nélküli
makró.

példa:
#include <stdio.h>

#define abs(x)     ((x) < 0 ? (-(x)) : x)
#define plusz(x,y) ((x)+(y))
#define csereInt(x,y)  {int z; z = x; x = y; y = z;}
#define csereStr(x,y)  {char* z; z = x; x = y; y = z;}

void main()
{
   int szam_1 = 10, szam_2 = 20;
   char* str_1 = „Hello világ!”;
   char* str_2 = „Hello world”;

   printf("Két szám összege: %d\n",plusz(szam_1,szam_2));
   // Két szám cseréje
   printf("Számok a csere előtt: %d, %d\n", szam_1, szam_2);
   csereInt(szam_1, szam_2);
   printf("Számok csere után: %d, %d\n", szam_1, szam_2);


   // Két szöveg felcserélése, fordítás
   printf("Fordítás előtt: %s, %s\n", str_1, str_2);
   csereStr(str_1,str_2);
   printf("Fordítás után: %s, %s", str_1, str_2);
}
Megjegyzések:
·   a makró törzsében a paramétereket kerek zárójelben kell
  használni, különben más értelmezést kaphatnak pl.: a plusz(x,y)
  makró minden esetben helyes eredményt ad, viszont egy szorzatot
  tartalmazó függvényszerű makró nem.
·   miután szöveghelyettesítésről van szó, így megadhatunk
teljes utasításblokkokat is, mint ez a két csereXxx(x,y)
makrónál is látható.
·   ha valamely átadott értéket sztringként szeretnénk
felhasználni ## operátor nagy segítség lehet a számunkra,
lássunk egy példát:
#include <stdio.h>
#define meg(a) ((x##a) + 10)

void main()
{
   int x1 = 8, x2 = 108;
   printf("Az első változó:   %d\n",meg(1));
   printf("A második változó: %d",meg(2));
}
  eredménye:
              Az első változó:        18
              A második változó: 118;
·   sortörést is el lehet helyezni: \ jellel.

Elődefiniált makrók
ANSI szabvány elődefiniált makrója:
Makró   Leírás
__DATE_ Fordítás dátuma (string)
_
__TIME_ Fordítás időpontja (string)
_
__FILE_ Forrás file neve (string)
_
__LINE_ Aktuális sor sorszáma (int)
_
__STDC_ Értéke 1, ha a fordító ANSI C,
_       különben nem definiált.
Ezt a C nyelvek továbbiakkal egészítik ki.

Feltételes fordítás
#if konstans kifejezés
    program részlet_1
#else
    program részlet_2
#endif
pl.:
#define DEBUG 1
…
#if DEBUG
   …
#else
   …
#endif