A C program szerkezete, típusai, konstansok

A C program szerkezete, típusai, konstansok

A C programok szerkezete sokkal kötetlenebb a Pascal programokhoz képest, de néhány fontos szabályt itt is be kell tartanunk.
A C nyelv case-szenzitív, azaz megkülönbözteti a kis és nagy betûket. A C nyelv a Pascal-hoz hasonlóan viszoylag kevés utasítást tartalmaz, sokkal inkább a beépített alprogramokra támaszkodik. Az alprogramok közül csak a függvények használatát támogatja, az eljárások speciális függvények. Ennek következménye, hogy amikor egy eljárást (esetleg paraméter nélküli függvényt) használunk, a függvény neve után ki kell tenni az üres zárójeleket. A C programok is blokkokból épülnek fel, a blokk kezdõ és zárószimbóluma: .
Minden C programnak tartalmaznia kell egy main() nevû függvényt. Ez a függvény speciális szerepet kap a C programokban, hasonlóan mûködik, mint a Pascal esetén a fõprogramot tartalmazó blokk. A main() függvény határozza meg az operációs rendszer számára a program belépési pontját.

A legegyszerûbb C program egyetlen sorban megírható:

main()

Mivel ebben az esetben a main() függvény törzse nem tartalmaz utasításokat, a program semmit nem csinál.
 
 

A C programok szerkezete:

Ezek után nézzünk meg egy még teljesebb példát:

#include <stdio.h    /* Elofordito utasitasok */
#define OSZTO 2

int x, y;            /* Globalis deklaraciok */

main()            /* Foprogram */

A program beolvas két számot, kiszámolja az összegüket, majd kiírja, hogy az összeg osztható-e kettõvel. Ezen a programon már sokkal inkább meg lehet figyelni a C programok felépítését. A C programok az ún. elõfordító utasításokkal kezdõdnek (#include ...   #define ...). Az #include utasítás a Pascal Uses utasításához hasonló. A #define utasítás ún makrok definiálására szolgál (ilyen a Pascal-ban nincs). A makrok a program során konstansokként használhatók fel, különbség a konstansokhoz képest, hogy a makrókat meg lehet szüntetni, ha már nincs rájuk szükségünk (#undef). A main() függvény törzse tartalmazza a scanf() és printf() függvény hívását. Az elsõ a billentyûzetrõl olvasást, a második a képernyõre írást valósítja meg. Ezek a függvények az stdio.h állományban van definiálva, ezért kellett az #include utasítással beépíteni a programban.
A return utasítás a szabályos kilépést szolgálja. A Pascal függvényeinek is mindig volt visszatérési értékük, amelyet a
FgvNev:= Kif; utasítással határoztunk meg. A C programok esetén a fõprogram maga is egy függvény (main()), amelynek szintén van visszatérési értéke. A C függvények visszatérési értékét a return utasítással határozhatjuk meg. (Érdekes, hogy a program akkor is fut, ha a return utasítást elhagyjuk, de ekkor a Borland C egy Warning-ot jelez, azaz nem szintaktikai, hanem szemantikai hibával állunk szemben.)

A C program írása során elõször az elõfordító utasításokat kell megadnunk. Az elõfordító utasítások közül két fontosabb:
 

Az elõfordító utasítások:

#include: a szükséges Header file-ok beépítése a programba. A Header file-ok a Pascal unit-okhoz hasonlítanak, de a Header file-ok standard szöveges állományok, a függvények  forráskódját tartalmazzák. Az #include utasítás lehetõvé teszi, hogy ezeket a függvényeket felhasználhassuk a programban.

#define: makrók definiálása. A makrók a C nyelv speciális lehetõségei közé tartoznak. A program elején definiáljuk õket, a programban konstans értékként használhatók fel. A konstansokhoz képest eltérés, hogy a makrókat a program futása során megsemmisíthatjük, ha nincs rá szükségünk, vagy a felhasznált névhez új értéket szeretnénk rendelni. Szintén fontos tulajdonság, hogy a makrók nemcsak értékek tárolására alkalmasak, segítségükkel egyszerû függvények is leírhatók, de ezzel a lehetõséggel nem foglalkozunk bõvebben. Általában a makrók azonosítóit nagy betûvel írjuk, hogy a program többi részétõl jól elkülöníthetõk legyenek.
 

Globális deklarációk:

A globális deklarációk a main() függvény törzsén kívül helyezkednek el. Ezek a deklarációk akkor lehetnek fontosak, ha a saját függvényeket szeretnénk használni, és a velük való kommuninkációt globális változókon keresztül szeretnénk megvalósítani. A globális deklarációs rész tartalmazhat változókat, konstansokat, függvényeket, típusokat egyaránt.
 

A main() függvény (fõprogram):

A globális deklarációkat a main() függvény fejrésze, majd törzse követi. A main() függvény törzsén belül lehetõségünk van újabb deklarációk elvégzésére, ezek a lokális deklarációk lesznek. Az itt deklarált változók, konstansok, típusok, függvények csak a main() függvény törzsén belül használhatók fel, tehát csak azok a függvények használhatják õket, amelyek szintén a lokális dekalrációs részben szerepelnek.
 

Lokális deklarációk:

A lokális deklarációk után következnek a program utasításai, a program tevékenységét leíró rész (fõprogram). A program (majdnem)  minden sorát pontosvesszõvel kell lezárni. (Szándékosan nem írtam utasítást!!!)

A main() függvény törzsének utolsó utasítása általában a return utasítás, amely után meg kell határozni, hogy a függvény (program) milyen értéket (egész) adjon vissza az operációs rendszer felé. A main() függvénybõl visszaadott értéket felhasználhatjuk az ERRORLEVEL változó segítségével az operációs rendszer szintjén (pld. batch file-ok készítése során).
 
 

A változók, típusok, konstansok deklarációja, a C nyelv típusai:

A C nyelv deklarációinak formája jelentõsen eltérõ a Pascal deklarációktól.

Változók deklarációja:

típus azonosító; Például:   int a;

A típus meghatározása után egyszerre több azonosítót is felsorolhatunk. Pld: int a, b;
A deklaráció során a változó azonnal kaphat értéket. Pld: int a=5, b=2;  vagy  int x=2, y;

Konstansok deklarációja:

const azonosító=érték; Például: const pi=3.14;

A konstansok deklarációja a const foglalt szóval kezdõdik. Meg kell adni a konstans azonosítóját, majd egyenlõségjel után a konstans értékét. Bármilyen konstans deklarálható ilyen módon. Pld: const szov="Egyszeru szoveg";
A C nyelv nem engedi meg a típusos konstansok használatát (amely szerintem felesleges is lenne a változók deklaráció során megadható kezdõértéke mellett).

Típusok deklarációja:

typedef típusleírás típusazonosító;  Például: typedef double valos;

A saját típusok deklarálása a typedef foglalt szóval lehetséges. Elsõsorban összetett típusok esetén alkalmazzuk, mivel a függvények C nyelvben sem engedik meg az összetett típusú paraméterek használatát.
Egy bonyolultabb típusdeklaráció:

typedef struct BOOK konyv;
 

Az alprogramok készítésével (függvények deklarációja) nem foglalkozunk.
 

A C nyelv típusainak csoportosítása:

A C nyelvben is deklarálni kell a változókat használatuk elõtt, a deklaráció során megadott különbözõ tulajdonságok között az egyik legfontosabb a változó típusa. A Pascal nyelvhez hasonlóan a típus itt is meghatározza a változó által tárolható értékek jellegét, határait. A C nyelvben használható típusok csoportosítása:

Egyszerû (skalár) típusok:

    Aritmetikai típusok:
            Egész jellegû típusok:
            char
            signed char
            unsigned char
            int
            long int
            short int
            unsigned int
            unsigned long int
            unsigned short int
            enum
            Lebegõpontos (valós) típusok:
            float
            double
            long double

    Mutató típusok
 
 

Összetett típusok:

    Összeállított típusok:
        tömb típusok
        struktúra típusok
    Unió (union) típusok
 

Az egyszerû típusok elõállítása során gyakran használunk ún. típusmódosítókat, amelyek egy-egy alaptípus tulajdonságait módosítják, ilyen módon szinte egy új típust hoznak létre. (Pld: int; long int) A típusok között az alaptípusok a következõk:
char, int, float, double, enum, struct, union. Ezek közül a char, int, double típus tulajdonságait módosítva kapjuk a többi felhasználható típust.
 

Az alaptípusok jellemzõi:

char:
Egy karakter tárolására alkalmas típus, hossza 1 byte. Elõjel nélküli egész típus. A C nyelvben a karaktereket azonos módon kezelhetjük a 0..255 közé esõ egész számokkal, amelyek tulajdonképpen a karakter ASCII kódját jelentik. Módosítható típus.

int:
Egész számok tárolására használható elõjeles típus. Mérete általában megegyezik a gépi szó méretével, azaz hardverfüggõ. A szó általában 2 byte hosszú, de egyes C fordítók, és egyes processzorok esetében eltérés tapasztalható. Módosítható típus.

float:
Lebegõpontos (valós számok tárolására alkalmas) elõjeles típus, mérete 4 byte. 6 tizedesjegyig pontos, egyszeres pontosságú lebegõpontos típus. Nem módosítható típus.

double:
Dupla pontosságú lebegõpontos típus, mérete 8 byte. 15 tizedesjegyig pontos számolást tesz lehetõvé. Módosítható típus.

enum:
Felsorolt típus. Lehetséges értékei egy a felhasználó által megadott konstanshalmazból kerülnek ki. A felsorolt típus hosszúsága a felhasználó által felsorolt értékek számától függ, az értékek int típusú konstansként kerülnek értelmezésre.
Pld.: enum valasz ;
A példában szereplõ változó 3x2, azaz 6 byte-ot foglal a memóriában, mivel a lehetséges értékek száma három, az int típusról pedig feltételezzük, hogy 16 biten van tárolva.

struct:
Az összetett típusok közé tartozik. Hasonló a Pascal nyelv record típusához. Elsõsorban az adatállományok kezelése során használatos típus. A struktúra típusú változó méretét meghatározhatjuk, ha a struktúra tagjainak (mezõinek) méretét összeadjuk. Mindössze a deklarációban tér el a Pascal nyelvtõl.
Példa:

...
struct szem Szemely;
...

A példában egyszerre deklaráltunk egy típust és egy változót. A struktúra típusú változó a Szemely lesz, a struktúra típus a szem.

union:
Speciális, csak a C nyelv által támogatott típus. A struktúra adattipushoz áll legközelebb, de mûködése, és használatának jelentõsége merõben más. A union típus is eltérõ típusú mezõkbõl (tagokból) épül fel, de míg a struktúra esetén az egyes tagok a memóriában egymás után helyezkednek el, az unió tagjai közös kezdõcímet kapnak. Ezért az unió típusú változó mérete egyenlõ a leghosszabb tag méretével. Régebbi C változatok esetében a lehetõséget a memóriamegtakarítás miatt alkalmazták, ma speciális feladatok megoldása során használják.
 

A típusmódosítók:
 
A típusmódosítók segítségével az alaptípusok tulajdonságait (értéktartomány, tárolási méret) tudjuk módosítani. A típusmódosítók alkalmazásával tehát a meglévõ típusokból tudunk új típusokat elõállítani. A típusmódosítók néhány alaptípus esetén használhatók: int, char, double. A típusmódosítók: signed, unsigned, long, short. A típusmódosítók különbözõ kombinációit is alkalmazhatjuk, ha erre van szükség. A típusmódosítók segítségével elõállítható új típusok:

signed char:
    Elõjeles egész szám, mérete 1 byte, értelmezési tartománya: -127..128.
    A char típus alapértelmezett jellemzõin nem módosít.
 
unsigned char:
    Elõjel nélküli egész szám, mérete 1 byte, értelmezési tartománya: 0..255.

long int:
    Elõjeles egész szám, mérete 4 byte, értelmezési tartománya: -2147483648..2147483647.

short int:
    Elõjeles egész szám, mérete 1 byte, értelmezési tartománya: -32768..32767.
    Az int típus alapértelmezett jellemzõin nem módosít.

signed int:
    Egyenlõ az int típussal, alapértelmezett jellemzõin nem módosít.

unsigned int:
    Elõjel nélküli egész szám, mérete 2 byte, értelmezési tartománya: 0..65535.

signed long int:
    Egyenlõ a long int típussal.

unsigned long int:
    Elõjel nélküli egész típus, mérete 4 byte, értelmezési tartománya: 0..4294967295.

signed short int:
    Egyenlõ a short int típussal.

unsigned short int:
    Elõjel nélküli egész szám, mérete 2 byte, értelmezési tartománya: 0..65535.

long double:
    Kétszeres pontosságú lebegõpontos típus, mérete 10 byte, 19 tizedesjegyig pontos számolást tesz lehetõvé.

A típusmódosítókat a deklarálás során használjuk fel, nem összetett típusokat képeznek, tehát a módosított típusok is az egyszerû típusok közé tartoznak (ez a függvények készítése során lehet fontos).