Végre elkészült az első anyag a gyorstalpalóból. Mivel sokan nem nagyon találkoztatok a C-vel ( tudomásom szerint ) a legalapabbaktól indulunk.
Legeslegelső C programunk:
int main()
{
return 0;
}
A C nyelv függvények halmaza. Maga a főprogram is (main()) egy függvény. A függvénynek tetszőleges számú bemenő paramétere lehet, visszatérési értéke viszont csak egy. Bemeneti paraméterei most nincsenek későbbiekben tárgyaljuk.
Esetünkben a main-nak van visszatérési értéke mely tájékoztatja az OS-t hogy rendben lefutott-e ( return 0 ) vagy hiba történt ( return -1; ). Későbbiekben függvényekről és eljárásokról bővebben, most fogadd el hogy egy alap C program így épül fel.
Első C programunk:
#include <stdio.h>
int main()
{
printf("Hello IK-MI10'!\n");
return 0;
}
Futtatás után megjelenik a képernyőn egy kiírás (Hello IK-MI10'!). Alap "függvény" felépítése nem változott.
Megjelent az #include <stdio.h>. C-ben a különböző beépített, gyári függvények csoportosítva vannak úgynevezett 'header' fájlokban, melyeket használatuk előtt meg kell hívnunk (include-álnunk kell).
Most mi az stdio.h-t hívtuk meg ami annyit tesz Standard Input Output függvények találhatóak, ebben található a printf kiíratáshoz használt függvényünk. Ebben a header-ben még számos későbbiekben használatos függvény megtalálható. (pl.: scanf, fopen,...)
(Sokat használt headerek még math.h matematikai függvények, stdlib.h véletlen szám generátor, és sorolhatnám de mindent a maga idejében.)
A printf()-ben a kiírandó szöveget dupla idézőjelek közé kell tennünk. Amint látjuk a \n nem került kiírásra, vajon miért? Válasz igen egyszerű a \n sortörést hajt végre.
\n mintájára használhatóak még az alábbi formázások:
\t tabulátor
\r kocsi vissza
\f soremelés
\v függőleges tabulátor
Második programunk, avagy változó nélkül nincs élet:
#include <stdio.h>
int main()
{
int a = 5;
printf("a valtozo erteke: %d \n",a);
return 0;
}
Na itt már több minden van. C-ben a változót, változó típusa ( lentebb milyenek vannak ) majd utána a változó neve
( ,-vel elválasztva többet is deklarálhatunk egyszerre). További előnye a c-nek, hogy a változónak kezdőértéket is adhatunk a deklarációnál.
Következő sorban kiíratjuk, hogy: 'a valtozo erteke: 5'. A printf() függvényben a változókat csak úgy tudjuk kiíratni, hogy az idézőjelek között % jel után megadjuk a változó típusát, a kiírás formátumát majd az idézőjelek után vesszőkkel elválasztva fölsoroljuk a változók neveit.
Kiíratáshoz szükséges:
%d decimális egész
%u előjel nélküli decimális egész
%f lebegőpontos
%lf hosszú lebegőpontos
%c karakter
%s sztirng vagy karakter tömb
További paraméterezéshez:
printf(”…%5.2f”,f);
Az f valós változót 5 mezőre írja ki 2 tizedes pontosságga
C típusai:
Adattípus Értékkészlet Méret (byte) Pontosság(jegy)
char -128..127 1
unsigned char 0..255 1
int -32768..32767 2
unsigned int 0..65535 2
long int -2147483648..2147483647 4
unsigned long int 0..4294967295 4
float 3.4e-38..3.8e+38 4 6
double 1.7e-308..1.7e+308 8 15
long double 3.4e-4932..3.4e+4932 10 19
Harmadik programunk:
int main()
{
int a = 5;
a+=15;
printf("a valtozo erteke: %d \n",a);
return 0;
}
Változóink értékét menetközbe változtatni kell erre a C sokkal rövidebb formákat ( lusta programozó ne gépel feleslegesen ugye ). a+=15 annyit tesz a = a + 15 az a értéke 20 lesz, amit kiíratunk.
Hagyományos forma Tömör forma
a=a+b a+=b
a=a-b a-=b
a=a*b a*=b
a=a/b a/=b
a=a%b a%=b //maradékos osztás pascalban mod volt
a=a<<b a<<=b // bitek eltolása b hosszan balra
a=a>>b a>>=b // bitek eltolása b hosszan jobbra
a=a&b a&=b // a és b
a=a|b a|=b // a vagy b
a=a^b a^=b // a kizáró vagy b
Amennyiben változónk értékét csak 1-el szeretnék növelni/csökkenteni C erre is kínál megoldást. a++ az a értékét növeli egyel, a-- az a értékét csökkenti 1-el. ++a egyenlő a a++ és --a is a-- viszont kettő között különbség hogy amikor elől van a(z) ++/-- előbb növeljük a változó értékét majd végrehajtjuk a további műveleteket.
Pl.
#include <stdio.h>
int main()
{
int a = 5, b,c;
b = ++a;
c = a++;
printf("a valtozo erteke: %d, b valtozo erteke: %d, c valtozo erteke: %d\n",a,b,c);
return 0;
}
Eme példából látható a különbség a két növelés között. ( Csökkentésnél is ugyan így működik )
A mutatókról az eddigiek során még nem volt szó, de a teljesség kedvéért megemlítünk két egyoperandusú műveletet, mely a mutatókhoz (pointerek) kötődik. & operátor a változónak a címe.
int main()
{
int a , *p;
p = &a
*p = 5
printf("a valtozo erteke: %d \n",a);
return 0;
}
Ebben a példában a p egy egész típusú változóra mutat, értékadásnál pedig az a változó memóriabeli címét kapja meg. Ha erre a címre új értéket akarunk írni, akkor a * (indirekt hivatkozás) operátort kell használnunk.
*p = 5 egyenértékű az a=5 értékadással. Későbbiekben jobban belemászunk a pointerekbe mert hasznos dolog és mert szükségünk is lesz rájuk elég sokszor.
Ne csak kiírni tudjunk kérjünk be változó értékeit!:
A formázott adatbeolvasást a scanf függvény segítségével tehetjük meg. A függvény általános formája a következő:
scanf(formátum, argumentumlista)
A scanf karaktereket olvas a billentyűzetről, majd a formátum alapján értelmezi azokat, ha a beolvasott karakterek megfelelők, akkor konvertálja őket. Ha az input valamilyen ok miatt nem felel meg a formátum előírásainak, akkor a scanf befejezi az olvasást, még akkor is, ha az argumentumlista szerint további karaktereket is be kellene olvasnia.
A scanf függvénynek visszatérési értéke is van. A sikeresen beolvasott adatok számát adja vissza. Nézzünk néhány példát a scanf használatára.
int a ;
char c;
printf(”Kérek egy egész számot és egy betűt”);
scanf(”%d%c”,&a,&b)
A példából látszik, hogy az egyszerű adatokat cím szerint kell beolvasni. Az argumentumlistában az &a és az &c a változók memóriabeli címére utal. A formátumban ugyanazokat a karaktereket használhatjuk, mint a printf esetében korábban tettük. Ez a sor egy számot és egy karaktert olvas be egymás után, nem tesz közéjük semmilyen elválasztó jelet. Nyilván, ha egy scanf-fel több értéket is akarunk beolvasni, akkor valamilyen határolóra szükség van.
int a ;
char c;
printf(”Kérek egy egész számot és egy betűt vesszővel elválasztva”);
scanf(”%d,%c”,&a,&c);
Figyeljük meg a változtatást. A formátumban egy vesszőt tettünk a második % jel elé. Ilyenkor a scanf beolvassa a vesszőt is, de azt nem tárolja. Ilyen módon bármilyen határoló karaktereket előírhatunk beolvasáskor.
A scanf segítségével sztringeket is olvashatunk be. Ebben az esetben nem használjuk az & operátort.
char sz[30];
scanf(”%s”,sz);
A scanf egy hasznos lehetősége, hogy az adatok szűrését is lehetővé teszi. Az előbbi deklaráció szerinti sz változó értéke csak számjegy, vagy hexadecimális jegy lehet, akkor azt a következő szűréssel valósíthatjuk meg:
scanf(”%[0-9a-fA-F]”,sz)
A komplementer halmaz megadására is van módunk:
scanf(”%[^0-9]”,sz)
Ezzel a szűréssel csak betűk kerülhetnek a sztringbe.
Példaprogramunk:
#include <stdio.h>
int main()
{
int a,b;
printf("Kerek két számot vesszővel elválasztva: ");
scanf("%d,%d",&a,&b);
printf("Ket bekert szám osszege: %d",a + b);
return 0;
}
