X *****************************************************************************
C Bevezetés
X *****************************************************************************
K Egymásba ágyazhatók-e a /* */ stílusú megjegyzések a C nyelvben?
R Igen.
J Nem.
M A preprocesszor. A /* után nem veszi figyelembe az újabb /*-ot, hanem az
@ első */-t tekinti a megjegyzés végének.
X -----------------------------------------------------------------------------
K Okoz-e fordítási idejű hibát, ha egy C nyelvű deklarációt, definíciót, ill.
@ utasítást azonosítók ill. operátorok között elhelyezett sortörésekkel több
@ sorra bontunk szét?
J Nem, sőt olykor a jobb érthetőség érdekében kívánatos is a kódot több sorba
@ tördelni.
R Igen, mert a C nyelvben minden sorban új utasítás kezdődik.
R Definíció esetében nem, deklarációt és utasítást viszont nem lehet több sorba
@ törni.
X -----------------------------------------------------------------------------
K Melyik kódolási technika javasolt az alábbiak közül?
@ A:
@   while(i>n){
@       printf("%d\n",i);
@   }
@
@ B:
@   while(i>n)
@   {
@       printf("%d\n",i);
@   }
R Csak az A
R Csak a B
J Mindkettő.
M Ha egy blokkot több sorba törünk, akkor a kódra pillantva azonnal látsszon,
@ hogy mi tartozik a blokkhoz.
X -----------------------------------------------------------------------------
K Melyik kódolási technika javasolt az alábbiak közül?
@ A:
@   while(i>n){
@       printf("%d\n",i);
@   }
@
@ B:
@   while(i>n){
@   printf("%d\n",i);}
J Csak az A
R Csak a B
R Mindkettő.
M Ha egy blokkot több sorba törünk, akkor a kódra pillantva azonnal látsszon,
@ hogy mi tartozik a blokkhoz.
X -----------------------------------------------------------------------------
K Melyik kódolási technika javasolt az alábbiak közül?
@ A:
@   if(a>b)
@   printf("Nyaktekerészetimellfekvenc.");
@
@ B:
@   if(a>b)
@       printf("Gőzpöfögészetitovalöködönc.");
R Csak az A
J Csak a B
R Mindkettő.
M Ha egy blokkot több sorba törünk, akkor a kódra pillantva azonnal látsszon,
@ hogy mi tartozik a blokkhoz.
X -----------------------------------------------------------------------------
K Az a kódrészlet, ami csak a függvény nevét, visszatérési típusát és 
@ paramétereinek típusát tartalmazza a
J függvénydeklaráció.
R függvénydefiníció.
X -----------------------------------------------------------------------------
K A függvény nevét, visszatérési típusát, paramétereinek nevét és típusát,
@ valamint a függvénytörzset, azaz a függvény megvalósítását tartalmazó
@ programrész a
R függvénydeklaráció.
J függvénydefiníció.
X -----------------------------------------------------------------------------
K Melyik állítás igaz az alábbiak közül?
J A függvény definíciójának része a függvény deklarációja, azaz prototípusa.
R A függvény deklarációjának, azaz prototípusának része a függvény definíciója.
X -----------------------------------------------------------------------------
K Melyik kifejezés változódefiníció az alábbiak közül?
@ A: int a;
@ B: extern int a;
@ C: static int a;
@ D: int a=9;
J Az A, C és D egyaránt.
R Mind a négy.
R Csak a D.
X -----------------------------------------------------------------------------
K Melyik kifejezés változódeklaráció de nem definíció az alábbiak közül?
@ A: int a;
@ B: extern int a;
@ C: static int a;
@ D: int a=9;
R Az A, B és C egyaránt.
R Csak az A.
J Csak a B.
X -----------------------------------------------------------------------------
K Mire szolgálnak a fejléc (header) fájlok a C nyelvben?
J Tartalmazzák a több forrásmodulban használt függvények és változók
@ prototípusait és a konstansokat, így ezeket nem kell minden modulba kézzel
@ beírni vagy bemásolni.
R Semmi szükség rájuk, az a céljuk, értelmes tartalomnak tűnve a
@ programozáshoz nem értő kollégáinkkal elhitessük, hogy többet dolgoztunk.
R Tartalmazzák a több modulban használt függvények kódját, így ezeket nem kell
@ minden modulba kézzel beírni vagy bemásolni.
X -----------------------------------------------------------------------------
K Az előfordító
J eltávolítja a megjegyzéseket és a felesleges whitespace karaktereket a
@ C kódból, bemásolja a #include után megadott fájlok tartalmát a #include
@ sora helyére, behelyettesíti a #define-nal megadott makrókat és konstansokat
@ a kódba, a #if feltételes fordítás feltételét kiértékelve egyes
@ kódrészleteket eltávolít a kódból, és más, itt fel nem sorolt dolgokat is
@ végez.
R félig lefordítja a kódot, így a rendes fordítónak könnyebb dolga van.
R buta, ezért lehetőleg nem használjuk, helyette a modernebb utófeldolgozót
@ használjuk.
X -----------------------------------------------------------------------------
K Mit mondhatunk a következő kódrészletről?
@ printf("A %s sztring " "%d hosszú",s,strlen(s));
R Szintaktikai hiba
R Kimaradt a vessző
J Minden rendben, csak kettészedtük a formátumsztringet
M Ha két karakterlánc között csak whitespace karakterek vannak,
@ akkor a fordítóprogram egyesíti azokat, így ez valójában így is jó:
@ printf("A %s sztring %d hosszú",s,strlen(s));
X -----------------------------------------------------------------------------
K Mi a szerepe a main elnevezésű függvénynek?
J Kijelöli a program belépési pontját, a program futása a main függvény
@ indításával kezdődik meg.
R Semmilyen szerepe nincs, egyszerűen csak szeretjük így hívni az egyik
@ függvényt.
R Csak ebből a függvényből tudunk más függvényeket meghívni.
X -----------------------------------------------------------------------------
K Mit ír ki az alábbi kódrészlet?
@ int a;
@ printf("%d", a);
J szemetet
R 0
R 1
X -----------------------------------------------------------------------------
F61 Mit ír ki az alábbi programrészlet?
@ printf("%d", 0247);
M A 0-val kezdődő konstans oktális szám, de a %d decimális alakban írja ki.
X -----------------------------------------------------------------------------
K Mit mondhatunk a következő kódrészletről?
@  int p[2]={2,3}; int j=6;
@  j=j/*p; /* j-t elosztjuk a p első elemével */;
R A megjegyzésnek megfelelően a j változó értéke 3 lesz (6/2)
R Nem használhatjuk a * operátort egy tömb neve előtt
J A j változó nem változik, mert az első /*-gal kezdődik a megjegyzés
X -----------------------------------------------------------------------------
K Vizsgálhatjuk-e a túlcsordulást a következő kódrészlettel?
@  int i,j; ...
@  if ((i+j)>INT_MAX)) ...
R Igen, ez így jó
J Nem, mert semmilyen egész művelet ideiglenesen sem lesz nagyobb, mint az
@ ábrázolható legnagyobb szám, ezért ez a feltétel akkor sem teljesül a
@ programban, ha matematikailag az összeg nagyobb, mint INT_MAX
X -----------------------------------------------------------------------------
K Ha egy double visszatérési típusú, egyetlen double paramétert váró függvényt
@ meg akarunk hívni a main függvényből, akkor a forrásállományban a main 
@ függvény definíciója előtt:
J a meghívandó függvénynek legalább a prototípus deklarációjának szerepelnie
@ kell (ill. egy header állományt kell #include-olni, amiben szerepel).
R a meghívandó függvény deklarációjának és definíciójának is szerepelnie
@ kell (ill. egy header állományt kell #include-olni, amiben szerepel).
R nem szükséges semmi, amennyiben a fordító valahol máshol megtalálja 
@ a meghívandó függvényt.
M A fordító előre halad a forrásállományban, és a meghívás pontjánál
@ előzetes prototípus deklaráció hiányában feltételezi a függvényről az int
@ visszatérési típust és 1 db. int paramétert, ami komoly zűrzavarhoz 
@ vezethet!
X -----------------------------------------------------------------------------
K Mit ír ki a program
@ #define ot 1+4
@ #define tiz 1+9
@ printf("%d", ot*tiz );
R 50
J 14
R 38
M Az előfeldolgozó szövegesen helyettesít: printf("%d", 1+4*1+9 );
X -----------------------------------------------------------------------------
K Csak a megjegyzések használatával tudunk ideiglenesen eltávolítani
@ kódrészeket?
R Igen.
J Nem, például a #if 0 ... #endif preprocesszor utasításokkal is lehet.
R Nem lehet ideiglenesen eltávolítani kódrészeket.


X *****************************************************************************
C Azonosítók, operátorok
X *****************************************************************************

K Az alábbi azonosítók különbözőnek számítanak-e?
@ krumpli, kRuMpLi
J Igen.
R Nem.
R Az adott operációs rendszertől függ.
M A C nyelv érzékeny a kis és nagy betűk különbözőségére.
X -----------------------------------------------------------------------------
K Mely azonosítók hibásak az alábbiak közül?
@ A: Ag97KSrzd_sfa
@ B: Pici%Maci
@ C: Almas Pite
@ D: switch
@ E: ThisIsAVariable
J B, C és D
R A, B és E
R A, B és D
M Az A elég csúnya de nem hibás, a B és a C nem megengedett karaktert tartalmaz
@ a D pedig egy foglalt szó.
X -----------------------------------------------------------------------------
F1 Mi a $u1|$u2 kifejezés értéke?
M Bitenkénti vagy kapcsolat
X -----------------------------------------------------------------------------
F3 Mi a $u1&$u2 kifejezés értéke?
M Bitenkénti és kapcsolat
X -----------------------------------------------------------------------------
F4 Mi a $u1^$u2 kifejezés értéke?
M Bitenkénti kizáró vagy kapcsolat
X -----------------------------------------------------------------------------
F5 Mi a $u1^$u2^$u1 kifejezés értéke?
M Bitenkénti vagy kapcsolat, a^a=0, a^b^a=b^a^a=a^a^b=b. Azonos számok kizáró
@ vagy kapcsolatba hozva páronként kiejtik egymást.
X -----------------------------------------------------------------------------
F12 Mi a(z) !$u1 || $u2 kifejezés kiértékelésének eredménye?
M Logikai vagy kapcsolat, logikai értéket ad vissza, ami egészként 0 vagy 1
@ lehet. Bemenete is logikai érték, de tetszőleges egész is lehet. Ha a bemenet
@ 0, akkor hamisnak tekinti, ha nem 0, akkor igaznak.
X -----------------------------------------------------------------------------
F23 Mennyi lesz 'b' változó értéke az utasítás lefutása után, ha 'a' változó 
@ jelenlegi értéke $u1, 'b' változó jelenlegi értéke pedig $u2? 
@ (a >= b || b++ < 5)
M Mivel a >=b igaz, a || operátor jobb oldala már nem értékelődik ki.
X -----------------------------------------------------------------------------
F13 Mi a(z) $u1 ^ ~$u1 kifejezés kiértékelésének eredménye?
M Mivel a bitenkénti negált azokon a helyeken tartalmaz 1 értéket, ahol az
@ eredetiben 0 szerepel, a bitenkénti kizáró vagy hatása megegyezik a bitenként
@ vagy hatásával. A kettes komplemens ábrázolásban a csupa 1 bitből álló számnak
@ a -1 érték felel meg.
X -----------------------------------------------------------------------------
F15 Mennyi 1<<$u1+$u2?
M Külön kiemelendő, hogy a C-ben a léptető operátor, bár szorzás jellegű
@ művelet, a precedenciája alacsonyabb az összeadásénál!
X -----------------------------------------------------------------------------
K Mennyi sizeof(char) értéke?
J 1, hiszen a sizeof definíció szerint az adott típus vagy
@ változó karakterméretben kifejezett méretét adja, egy karakter mérete pedig
@ egy karakterméretnyi.
R 8, hiszen egy karakter egy bájtot foglal, ami nyolc bit, a sizeof pedig
@ definíció szerint az adott típus vagy változó bitben kifejezett
@ méretét adja.
R 8 vagy 16, hiszen a karakter bitben kifejezett mérete nincs definiálva a C
@ nyelvben, UNICODE karakterek esetén pedig 16 bites a karakter. A sizeof
@ definíció szerint az adott típus vagy változó bitben kifejezett
@ méretét adja.
X -----------------------------------------------------------------------------
K Melyik a nagyobb, sizeof(unsigned) vagy sizeof(int)
J Egyforma méretűek.
R sizeof(unsigned) nagyobb.
R Nem lehet megmondani, mert a C nyelv nem definiálja a típusok konkrét
@ méretét.
X -----------------------------------------------------------------------------
K Melyik a nagyobb, sizeof(int) vagy sizeof(float)
R Egyforma méretűek.
R sizeof(float) nagyobb.
J Nem lehet megmondani, mert a C nyelv nem definiálja a típusok konkrét
@ méretét.
X -----------------------------------------------------------------------------
F6 Mit ír ki az alábbi függvény, ha szamol("3$s12") módon hívjuk meg?
@ void szamol(const char * s){
@     unsigned i,sum;
@     for(i=sum=0; s[i]; i++)
@        sum+=(s[i] >= '0' && s[i] <= '9') ? s[i]-'0' : 0;
@     printf("%u\n",sum);
@ }
M Végigmegy a sztringen, és ahol számjegyet talál benne, a számjegy karakterből
@ kivonva a '0' karaktert előállítja az adott számjegy értékét és ezeket
@ összeadja.
X -----------------------------------------------------------------------------
K Milyen értéket ad vissza az alábbi függvény, ha hívásakor a = 14, b = -63?
@ int f(int a, int b) {return a - b ? (a > b ? 1 : -1) : 0; }
J 1, mert a > b.
R 77, mert ennyi a - b;
R 0, mert a - b nem egyenlő nullával.
X -----------------------------------------------------------------------------
K Melyik igaz? Az (a == 0 || b % a ) kifejezés
J logikai igaz értéket ad, ha a nem osztója b-nek.
R hibás, mert a == 0 esetén a VAGY kapcsolat második tagjában 0-val való osztás
@ történik.
M Ha a || operátor előtt igaz állítás szerepel, az utána álló kifejezés nem
@ értékelődik ki.
X -----------------------------------------------------------------------------
K Mennyi lesz x értéke?
@ #define MAX(A,B) ((A)>(B)?(A):(B))
@ int a=5, b=7, x;
@ x = MAX(++a, ++b);
R 8.
R 7.
J 9.
M A preprocesszor csak egy szövegfeldolgozó. A fenti kód hatására a
@ következő utasítás képződik:  x=((++a)>(++b)?(++a):(++b));
@ Akármelyik szám is nagyobb, az kétszer lesz megnövelve; a kisebbik szám pedig
@ csak egyszer, mivel a ++ operátornak ez a mellékhatása. a ?: operátor "hamis
@ ága" pedig nem hajtódik végre. Érdemes inkább függvényt írni ilyen esetben.
X -----------------------------------------------------------------------------
F16 Mit ír ki a következő kód: printf("%d", $u1<$u2); ?
@ $u3? TRUE? 1?
M A C nyelvben nincsen külön logikai típus; egész számok helyettesítik azokat.
@ Egy logikai kifejezés értéke 0 vagy 1 lesz, attól függően, hogy igaz, vagy
@ hamis az eredmény. Jelen esetben 1, mert igaz.
X -----------------------------------------------------------------------------
K Melyik kifejezés helyes?
J (x++)+3
R (3++)+x
R x++++
X -----------------------------------------------------------------------------
F31 Mi az x értéke ha y = -$u1?
@ x = ((y + 2) < 0 ? (-(y + 3)) : (y + 2));
X -----------------------------------------------------------------------------
F35 Mennyi $u1 % 3 értéke?
M A % a maradékképzés jele.
X -----------------------------------------------------------------------------
F37 Mennyi lesz az alábbi sor lefutása után k értéke?
@ int i = $u1, j = $u2, k = 0;
@ k += ++i - j++  
X -----------------------------------------------------------------------------
F45 Mi a(z) ($u1*2)>>1 kifejezés kiértékelésének eredménye?
X -----------------------------------------------------------------------------
F46 Mi lesz x értéke az x = ($u1+1, ($u2+1, $u3+1)) kifejezés kiértékelése után?
X -----------------------------------------------------------------------------
K Mit ír ki az alábbi programrész?
@    int a = 0;
@    if (a = 0) printf("0"); else printf("nem 0");
J nem 0
R 0
X -----------------------------------------------------------------------------
F52 Mit ír ki az alábbi programrészlet?
@    int i = $u1;
@    i == 1 || i++;
@    printf("%d", i);
X -----------------------------------------------------------------------------
K Helyes-e az alábbi változódefiníció?
@ int double=1;
R Igen.
J Nem.
M A változó azonosítója nem lehet a C nyelv egyik kulcsszava sem.
X -----------------------------------------------------------------------------
K Mit jelent a következő sor:
@ int size, len(char []);
J size változó definíciója és a len függvény prototípusa
R Hibás, mert függvény prototípust nem lehet változó definícióval együtt
@ használni
R Hibás, mert a len változó típusa char[], a size pedig int
X -----------------------------------------------------------------------------
F56 Mennyi az értéke a következő kifejezésnek:
@ $u1 & $u2 && $u3
M A bitenkénti és kapcsolat magasabb precedenciájú, mint a logikai és kapcsolat
X -----------------------------------------------------------------------------
K Mennyi az a=b=c kifejezésben kiértékelése után a értéke?
R Az b változó régi értéke.
J Az b változó új értéke, azaz c értéke.
R 1, mert az értékadás sikere logikai igaznak felel meg.
X -----------------------------------------------------------------------------
K Mit mondhatunk a következő kódrészletről?
@ int i=2000;
@ printf("%d %d\n",!!++i,i);
J A paraméterként szereplő kifejezések kiértékelési sorrendje nem definiált,
@ így nem tudhatjuk milyen értékkel hívódik meg a printf (1,2000 vagy 1,2001)
R Az eredmény egyértelmű, mert ugyan nem tudható, hogy 2000 vagy 2001-nek
@ kell-e a logikai negáltját venni, de mindegy, hiszen az mindkettőre 0
@ és annak a negáltja biztos 1, tehát ami kiíródik: 1 2000
R Csak a következő kiírás a helyes: 1 2001, mert i-t előbb inkrementáljuk
X -----------------------------------------------------------------------------
K Mi a kifejezés értéke az adott definíció mellett?
@ Definíció: double d=39.9;
@ Kifejezés: ((int)d-3)/10
J 3
R 3.69
R 3.9
M A kifejezés értéke 3, mert a 36-ot egész osztással osztjuk el 10-zel.
X -----------------------------------------------------------------------------
K Mi lesz az average változó értéke?
@ int sum = x + (x + 1);
@ float average = sum / 2 * 1.0;
J x
R x + 0.5
R x + 1
M A sum/2 kifejezés környezetétől függetlenül egész osztást eredményez,
@ így sum=2x+1 páratlan szám 2-vel osztva x lesz.
X -----------------------------------------------------------------------------
K Mi a következő kifejezés értéke?   !(1&&1||1&&0)
R Hibás kifejezés
R Igaz
J Hamis
X -----------------------------------------------------------------------------
K Az alábbi változódefiníciók közül melyik hibás?
R int nice1x=0xface;
J int 0xface,nice1x;
R int nice1x;
M Azonosító, pl. változónév nem kezdődhet számjeggyel! Itt a 0xface nem egy
@ változó neve, hanem egy konstans hexadecimális (16-os számrendszerben 
@ megadott) érték!
X -----------------------------------------------------------------------------
F69 a=$u1; b=$u1 esetén mi lesz az (a++<++b || a++>$u2) kifejezés kiértékelése
@ után 'a' új értéke?
M A logikai || és && operátor második operandusa nem értékelődik ki, és így a
@ mellékhatása (itt: növelés) sem érvényesül, ha az első operandus ismeretében
@ már megállapítható az igazságértéke az egész kifejezésnek!
X -----------------------------------------------------------------------------
F70 a=$u1; b=$u1 esetén mi lesz az (a++<b++ && 2 * a++ > --b + $u2) kifejezés 
@ kiértékelése után 'a' új értéke?
M A logikai || és && operátor második operandusa nem értékelődik ki, és így a
@ mellékhatása (itt: növelés) sem érvényesül, ha az első operandus ismeretében
@ már megállapítható az igazságértéke az egész kifejezésnek!
X -----------------------------------------------------------------------------
K A ciklus végrehajtása után mennyi lesz az i változó értéke?
@   int a[7] = {1,2,3,4,5,0,0};
@   int i;
@   for(i=0; a[i] & a[i+1]; i++ ) {}
R A ciklus addig fut, amíg az aktuális és a rákövetkező tömbelem értéke 0,
@ tehát az i értéke 5 lesz.
R A ciklus addig fut, amíg az aktuális vagy a rákövetkező tömbelem értéke 0,
@ tehát az i értéke 4 lesz.
J Az i értéke 0 marad.
M binárisan 01&10
X -----------------------------------------------------------------------------
K Mennyi lesz az r változó értéke? int r, a=1, b=2; r = a << 2 + b;
R 6
R 8
J 16
M A biteltolás precedenciája kisebb, mint az összeadásé, így értelmeződik: 
@ r = a << (2 + b)
X -----------------------------------------------------------------------------
K Mit ír ki a következő kódrészlet?
@   int a=2, b=6, c=2;
@   if( a < b < c ) printf("novekvo"); else printf("csokkeno");
R csokkeno
J novekvo
R az a<b<c kifejezés szintaktikailag hibás, ezért a program nem fordul le.
M A kifejezés értelme: (a<b)<c, ahol a<b logikai igaz, azaz 1, 1<2 pedig igaz.
X -----------------------------------------------------------------------------
K Mit ír ki a következő kódrészlet?
@       #define ZZ(i) ((i)<2?(i):(i)+1)
@       int j = 0;
@       printf("%d", ZZ(j++)); printf("%d", ZZ(j++)); printf("%d\n", ZZ(j++));
R 123
J 146
R 246
M A makro behelyettesítődik: printf("%d", ((j++)<2?(j++):(j++)+1));
X -----------------------------------------------------------------------------
K Mit ír ki a következő kódrészlet?
@   int a[4]={1,0,3,5}; printf("%d", !!a[0]+!!a[1]+!!a[2]+!!a[3] );
R A program szintaktikailag hibás, mert !! operátor nem létezik.
R A kétszer egymás után írt logikai nem műveletet el lehet hagyni,
@ ezért a korszerű fordítók azt kioptimalizálják, és az eredmény a
@ számok összege, azaz 9 lesz.
J A kódrészlet a nem nulla elemek számát írja.
X -----------------------------------------------------------------------------

X *****************************************************************************
C Adatbevitel billentyűzetről, kiírás képernyőre
X *****************************************************************************

K Ha scanf függvénnyel olvasunk be értéket egy változóba, melyik állítás igaz?
J Minden esetben a változó memóriacímét kell megadni a formátumsztringet követő
@ felsorolásban.
R A sztring esetét kivéve mindig a változó memóriacímét kell megadni 
@ a formátum sztringet követő felsorolásban.
R A char s[100]; scanf("%s",&s[0]); beolvasás hibás, a helyes a 
@ scanf("%s",s); lett volna.
X -----------------------------------------------------------------------------
K Mi a getchar() függvény visszatérési típusa és miért?
J A típus int, mert a speciális karaktereket olyan kóddal jelzi, ami nincs
@ benne a karakterek értékkészletében (EOF:, ami a legtöbb implementációban -1).
R A típus int, mert a modern rendszerekben UNICODE kódolásúak a karakterek,
@ ami 2 bájton ábrázol egy betűt.
R A típus char, hiszen a getchar() karakteres adatok beolvasására való, ennek
@ típusa pedig a C-ben a char.
X -----------------------------------------------------------------------------
K Helyesen működik-e az alábbi kódrészlet?
@ printf("%6d %3d%%", -874, 79);
J Igen.
R Nem, mert a harmadik és a negyedik százalékjel után nem szerepel az
@ adatformátumot meghatározó karakter.
R Nem, mert a 6d és a 3d helytelen adatformátumok.
M A %% egy darab százalékjelet jelenít meg.
X -----------------------------------------------------------------------------
K Helyesen működik-e az alábbi kódrészlet?
@ printf("%6d %3d%%", -874);
J Nem, mert a formátumfüzér alapján a függvény két bemeneti argumentumot várna.
R Igen.
R Nem, mert hibás a formátumot megadó első paraméter.
X -----------------------------------------------------------------------------
K Helyes-e az alábbi program?
@ char *sztring;
@ scanf("%s", sztring);
R Igen; tetszőleges hosszúságú szót olvas be a billentyűzetről.
J Nem; sztring változó inicializálatlan.
X -----------------------------------------------------------------------------
K Mit ír ki az alábbi kód, ha a szabványos bemenetre beírjuk, hogy:
@ Hello, vilag!
@ char sztring[10]; scanf("%s", sztring);
R "Hello, vilag!", mert az enter leütéséig olvas.
J "Hello,", mert csak a szóköz karakterig olvas.
R "Hello, vi", mert a sztringünkbe csak 9 karakter fér, plusz egy lezáró nulla.
X -----------------------------------------------------------------------------
K Mennyi strlen("Hello, vilag!\n")?
J 14.
R 15.
R 16.
X -----------------------------------------------------------------------------
K Mit ír ki az alábbi program?
@ main(){ char c = 'X'; printf(c); }
J A program futása memóriaelérési hibához vezethet.
R Egy X karaktert.
R Az X karakter ASCII kódját
M A printf első argumentumába formátumsztringet vár, így ez esetben pointerként
@ kezel egy egész értéket, ami memóriaelérési hibához vezethet.
X -----------------------------------------------------------------------------
K Mit jelent a printf("%d", variable); kifejezésben a %d?
J Azt jelenti, hogy a változó értékét decimális egész formában kell kiírni.
R Azt jelenti, hogy csak 1 változó értékét kell kiírni.
R Azt jelenti, hogy a változó értékét dupla pontosságú lebegőpontos formában
@ kell kiírni
X -----------------------------------------------------------------------------
K Melyik header fájlban található a scanf és a printf prototípusa?
J stdio.h
R stdlib.h  
X -----------------------------------------------------------------------------
F24 Hány karakterre fogja kiírni a következő kódrészlet a számot? 
@ double d = $u1$u2.$u3$u4;
@ printf("%$u5.2f", d);
X -----------------------------------------------------------------------------
K Mi az értéke az a, b, c-nek ha a felhasználó a szabványos bemeneten a következő
@ szöveget adja meg?
@ Hello 14 736.55 uncle sam
@ int b; char a[30], c[30];
@ scanf("%s %d %*f %s", a, &b, c);
J Hello 14 uncle
R Hello 14 736.55
R Szintaktikai hibás a kódrészlet.
X -----------------------------------------------------------------------------
F32 Mennyi a kiírt átlag?
@ printf("Átlag: %d\n", ($u1+$u2+$u3)/3);
M Egész osztás
X -----------------------------------------------------------------------------
K Mit ír ki a következő program?
@ #include <stdio.h>
@ void main() {	int a=234; printf("%06d\n",a);} /* main() */
R <SPACE><SPACE><SPACE>234
J 000234
R 234<SPACE><SPACE><SPACE>
X -----------------------------------------------------------------------------
K Mi a visszatérési értéke a scanf("%lf", &d)függvényhívásnak?
J 0, 1, vagy EOF.
R Nincs is visszatérési értéke.
R Ha sikeres a beolvasás, akkor 0 egyébkent -1.
X -----------------------------------------------------------------------------
F38 Mit ír ki a következő kódrészlet?
@ printf( "\"alma\"" );
M A \" sztrigkonstansban idezőjelet jelent.
X -----------------------------------------------------------------------------
K Melyik változat helyes, ha a standard bemenetről érkező karaktereket
@ fájl végig fel akarjuk dolgozni a void process(char c) függvénnyel?
R while (c = getchar() != EOF)
@   process(c);
J while ((c = getchar()) != EOF)
@   process(c);
M Az összehasonlító operátor nagyobb precedenciájú, így az elso esetben c
@ értéke az összehasonlítás eredménye lenne, azaz 0 vagy 1.
X -----------------------------------------------------------------------------
K Melyik utasítás ad determinisztikus eredményt?
@ (A) printf("%s%s", "%s");
@ (B) printf("%s", "%s%s");
R Csak (A)
J Csak (B)
R Mindkettő
X -----------------------------------------------------------------------------
K Mit ír ki a következő kódrészlet?
@ int i = 0;printf("%d", (i++)+(++i) );
R 2
R 3
J Nem lehet tudni
X -----------------------------------------------------------------------------
K Meddig olvassa be a bemenetről a karaktereket a scanf függvény?
R Amíg Enter-t nem ütünk.
R Amíg Space-t nem olvas.
J Ameddig illeszteni tudja a bemenetet a megadott formátumsztringre.
X -----------------------------------------------------------------------------
K Mit ír ki az alábbi program?
@ main(){ char c = 'X'; printf("%d", c); }
R A program futása memóriaelérési hibához vezethet.
R Egy X karaktert.
J Az X karakter kódját
X -----------------------------------------------------------------------------
K Mit ír ki az alábbi kód?(ha az integer mérete 4 bájt)
@ unsigned int u= UINT_MAX;
@ printf("u= %d",u);
R u= 4294967295 (=UINT_MAX)
J u= -1
X -----------------------------------------------------------------------------
K Mit ír ki az alábbi kód?(ha az integer mérete 4 bájt)
@ unsigned int u= UINT_MAX;
@ int z=-1;
@ printf("%d",u==z);
J 1
R 0
R Szintaktikailag hibás a kód
X -----------------------------------------------------------------------------
K Meddig fut a következő ciklus?
@ int i;
@ while( scanf( "%d", &i ) == 1 );
R Csak 1 db számot olvas be
J Fájl végéig, vagy addig, amíg számokat írunk be
R Végtelen ciklusban olvassa be a számokat, amíg az 1-es számot nem írjuk be
X -----------------------------------------------------------------------------
F60 Mit ír ki a képernyőre az alábbi függvényhívás:
@ printf("%0*d", 5, $u1); 
M Paraméterben adjuk meg a kívánt szélességet.
X -----------------------------------------------------------------------------
K A printf függvénnyel nem lehet pointert kiíratni.
R Igaz.
J Nem igaz és lehet értelme is.
R Nem igaz, de nincs értelme, mert visszaolvasva már nem lehetünk benne 
@ biztosak, hogy érvényes a kiírt cím.
M A nulla vagy nem nulla érték mindenképpen hordozhat jelentést.
X -----------------------------------------------------------------------------
F62 Mit ír ki az alábbi program?
@ printf("%.f", $u1.$u2);
X -----------------------------------------------------------------------------
K Igaz-e hogy két egész számot így is be lehet olvasni: scanf("%d%d",&n,&m)?
J Igaz
R Nem, mert a két szám között kell legyen whitespace karakter, ezért
@ ezt csak így lehet: scanf("%d %d",&n,&m)
R Felesleges az & operátor használata
X -----------------------------------------------------------------------------
K Melyik állítás igaz? (csak egy jó)
R A scanf függvény visszatérési értéke EOF ha nem sikerült beolvasni az adott
@ formátummal egy adatot sem
J A scanf függvény terminálódik, amikor az inputon olyan adat érkezik, ami
@ nem feleltethető meg a formátumvezérlő sztringnek
R Ha a scanf függvény formátumvezérlőjében egy fix szöveg van akkor addig
@ olvasunk, ameddig meg nem kapjuk ezt a szöveget az inputon
X -----------------------------------------------------------------------------
K Melyik a helyes módja a beírt számok megszámolásának?
J int i,n=0; while (scanf("%d", &i)==1) n++;
R int i,n=0; while (!feof(stdin)) { n++; scanf("%d", &i); }
R int i,n=0; while (scanf("%d", &i)==1 && i!=EOF) n++;
M Ha sikertelen a beolvasás, i értéke nem változik, viszont lehet a fájlban
@ EOF értékű valódi adat, ami hibás működést eredményezne.
X -----------------------------------------------------------------------------
K Melyik programrészlet alkalmas leginkább egy könyv címének bekérésére?
J printf("A könyv címe:"); fgets(nev, sizeof(nev), stdin);
R printf("A könyv címe:"); scanf(nev);
R printf("A könyv címe:"); scanf("%s", nev);
M A fgets()-sel a sor végéig olvashatunk.
X -----------------------------------------------------------------------------
K Miért más a formátumvezérlő sztring double típus esetében?
@ (A printf-nél %f, míg a scanf-nél %lf)
J A printf esetében nincs értelme megkülönböztetni a float és a double
@ típusokat, mert a float változó double-re konvertálódik a paraméterátadáskor
R Nem feltétlenül más, ugyanazzal is helyes
R Valóban más, de fordítva van, mert ilyenre sikerült a szabvány
X -----------------------------------------------------------------------------
K Mi történik a következő kódrészletben, ha a bevitt karakterek száma 20?
@ char s[10]; gets(s);
R Semmi különös, az s változóval elérhető lesz mind a 20
R A 20-ból csak 10 lesz figyelembe véve, mert s mérete ennyi
J A pontos esemény implementációfüggő, de mindenképpen valami hiba lesz,
@ mert a 20 karakterből csak az első 10 kerül az s tömbbe, a többi a memória
@ utána következő részére kerül, amiről általánosan nem mondhatunk semmit
M A gets(s) helyett javasolt az fgets(s,10,stdin); használata, így nem lépünk
@ ki a tömbből.
X -----------------------------------------------------------------------------

X *****************************************************************************

C A C nyelv utasításai
X *****************************************************************************

X -----------------------------------------------------------------------------
F17 Mit ír ki az alábbi program?
@ int main(){
@   char s[] = "Utalom a kaposztat!!"; s[$u1] = 0; printf (s); return 0;
@ }
M A printf függvény az első \0 karakterig írja ki a sztringet
K Hányszor fut az alábbi ciklus?
@ while(12)printf("*");
J Végtelen ciklus, addig ismétlődik, amíg le nem lőjük a programot.
R 12-szer fut le, ezt jelzi a megadott szám.
R Egyszer sem fut le, mert szintaktikai hibás. A while ciklus zárójelei között
@ egy logikai kifejezésnek kellene állnia, pl. hogy i<12.
M A C nyelvben az egész számok logikai jelentéssel bírnak: 0=hamis, nem 0=igaz.
X -----------------------------------------------------------------------------
K Mi igaz az alábbi ciklusra?
@ for (i = j = 2; i = j; j--) printf("*");
J Két darab csillagot ír ki.
R Hibás, mert a for ciklus középső elemében nem logikai egyenlőség vizsgálat
@ van, hanem értékadás.
R Nem ír ki semmit, mert az inicializáló részben egyenlővé tettük i-t és j-t,
@ ezért rögtön az első vizsgálatnál kilép.
X -----------------------------------------------------------------------------
K Mit történik a continue utasítás hatására ciklusban?
J A while, for és do-while ciklusok soron következő iterációját indítja el,
@ így az aktuális iteráció hátralévő utasításait átugorja.
R Hatására while, for és do-while ciklusok megszakadnak és a vezérlés a ciklus
@ utáni első utasításra adódik át.
R Hatására a program végrehajtása a megadott címke utáni első utasítással
@ folytatódik.
X -----------------------------------------------------------------------------
K Mit történik a break utasítás hatására ciklusban?
R A while, for és do-while ciklusok soron következő iterációját indítja el,
@ így az aktuális iteráció hátralévő utasításait átugorja.
J Hatására while, for és do-while ciklusok megszakadnak és a vezérlés a ciklus
@ utáni első utasításra adódik át.
R Hatására a program végrehajtása a megadott címke utáni első utasítással
@ folytatódik.
X -----------------------------------------------------------------------------
K Mi a hatása a break-nek az alábbi kódban?
@ for(;a>b;a--){
@     switch(x){
@         case 1: break;
@         case 2: continue;
@     }
@ }
J Kilép a switch-ből, és mivel más utasítás nincs a ciklus végéig, a-- jön.
R A ciklus utáni utasítással folytatja, a-- műveletet már nem hajtja végre.
R A fordító nem tudja eldönteni, hogy a ciklusból vagy a switch-ből akarunk
@ kilépni, ezért fordítási hibát kapunk.
X -----------------------------------------------------------------------------
K Mi a hatása a continue-nak az alábbi kódban?
@ for(;a>b;a--){
@     switch(x){
@         case 1: break;
@         case 2: continue;
@     }
@ }
J A for ciklus a-- kifejezésének kiértékelésével folytatja a ciklus következő
@ iterációját.
R A switch elejére ugrik, és x-et ismét kiértékelve ugrik a megfelelő case-re.
R A for ciklus a<b kifejezésének kiértékelésével folytatja, a-- nem értékelődik
@ ki ebben ez iterációban.
X -----------------------------------------------------------------------------
F18 Mi lesz b értéke?
@ int a = $u1, b = $u2; if(b = a) b = $u3;
M Egyenlőségvizsgálat helyett értékadás van a feltételben.
X -----------------------------------------------------------------------------
F19 Mit ír ki a program?
@ main(){
@  int a = 2;
@  switch(a){
@   case 1: printf("A");
@   case 2: printf("B");
@   default: printf("C");
@  }
@  return 0;

@ }
M Nincs break, ezért B-t és C-t is kiírja.
X -----------------------------------------------------------------------------
F20 Mennyi lesz a értéke?
@ int a = $u1; for(i=0; i<10; i++); a+=( (a%2) ? 5 : (a+4)/3 );
M A for ciklus nem csinál semmit, mivel utána pontosvessző (üres utasítás van)
X -----------------------------------------------------------------------------
F25 Mi lesz a következő kódrészlet lefutása után az 'a' változó értéke?
@ int i,j;   float a,b;
@ for (a=i=$u1.6, j=b=$u2.5; a<13;  a+=b, j--) do i*=j; while (++i<a);
X -----------------------------------------------------------------------------
K Hányszor fut az alábbi ciklus?
@ while()printf("hello");
R Végtelen ciklus, addig ismétlődik, amíg le nem lőjük a programot.
R Addig fut, amíg meg nem nyomjuk az ENTER billentyűt.
J Egyszer sem fut le, mert szintaktikai hibás. A while ciklus zárójelei között
@ egy logikai kifejezésnek kellene állnia, pl., hogy i<12.
X -----------------------------------------------------------------------------
K Hányszor fut az alábbi ciklus?
@ for(i=10; ;i++);
J Végtelen ciklus.
R 10-szer fut le, ezt jelzi a megadott szám.
R Egyszer sem fut le, mert szintaktikai hibás. A két pontosvessző között egy
@ logikai kifejezésnek kellene állnia.
X -----------------------------------------------------------------------------
K Hányszor fut az alábbi ciklus?
@ while(0)printf("hello");
J Egyszer sem fut le.
R Végtelen ciklus, addig ismétlődik, amíg le nem lőjük a programot.
R Addig fut amíg, meg nem nyomjuk az ENTER billentyűt.
M A 0 logikai hamis.
X -----------------------------------------------------------------------------
K Hányszor fut az alábbi ciklus?
@ while(-100)printf("hello");
R Egyszer sem fut le, mert szintaktikai hibás.
J Végtelen ciklus.
R Addig fut amíg, meg nem nyomjuk az ENTER billentyűt.
X -----------------------------------------------------------------------------
K Mi lesz min értéke, az alábbi sor lefutása után?
@ min = min > adat ? min : adat;
J A min és az adat maximuma.
R A min és az adat minimuma.
R Mindig adat
X -----------------------------------------------------------------------------
K Melyik változat a biztonságos?
@    int a;
@    scanf("%d", &a);
@ a) if (100/a > 20) do_stg();
@ b) if (100/a > 20 && a != 0) do_stg();
@ c) if (a != 0 && 100/a > 20) do_stg();
@ d) if (a != 0)if(100/a > 20) do_stg(); 
R Mindegyik jó
R b), c) és d)
J c) és d)
X -----------------------------------------------------------------------------
F40 Mi az fv($u1) értéke?
@ int fv(unsigned x) {
@   int c=0;
@   for(; x; x>>=1) c+=x&1;
@   return c;
@ }
M A függvény a paraméterben lévő 1-es bitek számát adja vissza.
X -----------------------------------------------------------------------------
F41 Mi az fv($u1) értéke?
@ int fv(unsigned x) {
@   int c;
@   for(c=0; x; x>>=1) c++;
@   return c;
@ }
M A függvény azt adja vissza, hogy hány értékes bit van a paraméterként kapott
@ számban, tehát hogy hány biten lehet ábrázolni a kapott számot.
X -----------------------------------------------------------------------------
K Mit ír ki az alábbi program?
@ int sum(int x, int y) { return x+y; }
@ int main() {
@   int x = 3, y = sum(x++, ++x);
@   printf("%d\n", y);
@   return 0;
@ }
R 8
R 9
J Nem meghatározható, fordítótól függ.
M A paraméterek kiértékelésének sorrendje a szabványban nem meghatározott, így 
@ az eredmény fordítófüggő.
@ A programot Visual Studio 2008-cal fordítva az eredmény 9,
@ Dev-C++ 4.9.9.2-vel (gcc) fordítva pedig 8.
X -----------------------------------------------------------------------------
K Mit ír ki a következő kódrészlet?
@ int j = 5;
@ for (i = --j; i > 4; i--) { printf("x"); }
J Semmit 
R xxxx
R x
X -----------------------------------------------------------------------------
K Hányszor fut le az alábbi ciklus?
@ int i=2;
@ while(i--) printf("A");
R Egyszer
J Kétszer
R Háromszor
X -----------------------------------------------------------------------------
K Hányszor fut le az alábbi ciklus?
@ int i=2;
@ while(--i) printf("A");
J Egyszer
R Kétszer
R Háromszor
X -----------------------------------------------------------------------------
F58 Mit ír ki az alábbi program?
@ int i=$u1, j=$u2;
@ switch (i) {
@   default: j=$u3;
@   case 1: j=$u4;
@ }
@ printf("%d\n", j);
M Nincs break a default ágban, ezért továbbmegy a case 1 ágra.
X -----------------------------------------------------------------------------
K Ha egy if utasítás magja üres, akkor akár el is hagyhatjuk a programból.
R Igaz.
R Nem igaz, semmiképpen nem szabad elhagyni.
J Nem igaz, a feltételtől függ.
M A feltételben szereplő kifejezés mellékhatása sem hajtódik végre,
@ ha elhagyjuk a feltételes kifejezést.
X -----------------------------------------------------------------------------
K Mit csinál a for(;;); utasítás?
R Ez hibás utasítás, a fordító hibát jelez
R Ez egy felesleges utasítás, nem csinál semmit, a fordító kihagyja
J Ez egy végtelen ciklus
X -----------------------------------------------------------------------------

K Mi lesz ennek az utasításnak a hatása? 
@ a>5;
J Semmi; a kifejezés logikai értékét nem használjuk fel semmire.
R 'a' változóba egy 5-nél nagyobb érték kerül.
R Ha ezen a ponton, vagy valamikor később 'a' változó értéke 5, vagy annál
@ kisebb, a program hibával kilép.
X -----------------------------------------------------------------------------

X *****************************************************************************
C Függvények használata
X *****************************************************************************

F2 Mit ír ki a következő függvény, ha a bikini($u1); utasítással hívjuk meg?
@ void bikini(unsigned n){while(n>>=1)putchar('X');}
M A while ciklus addig fut, amíg a feltétel igaz. Az egész szám logikai
@ igaznak felel meg, ha értéke nem 0; hamis, ha 0. n>>=1 azt jelenti, hogy n
@ egész szám 1 bittel jobbra tolódik (2-vel való egész osztás), az így kapott
@ érték bekerül n-be, majd a while n értékét vizsgálja.
X -----------------------------------------------------------------------------
K Adott az alábbi függvénydeklaráció:
@ int compare(const void*, const void*);
@ Okoz-e fordítási idejű hibát az alábbi kódrészlet?
@ int a[] = {1,2,3};
@ int b[] = {4,5,6};
@ int r = compare(a, b);
J Nem.
R Igen.
X -----------------------------------------------------------------------------
K Mit ír ki az alábbi kódrészlet?

@ int f(int param){
@    printf("%d", param);
@    return param+2;
@ }
@ ...
@ x=f(5.7);
R "6", mert 5,7 egészre kerekítve 6.
J "5".
R "5.7".
M Az 5,7-es szám a függvényhívás pillanatában egész értékűre konvertálódik.
X -----------------------------------------------------------------------------
K Mi a különbség a függvény és a makró között?
J A függvény végrehajtása futtatáskor vezérlésátadással történik, míg a makró
@ fordítás előtt helyettesítődik be.
R A két elnevezés ugyanazt a fogalmat jelöli.
X -----------------------------------------------------------------------------
F22 Milyen értékkel tér vissza f, ha f($u1) paraméterekkel hívjuk meg?
@ int f(int a)
@ {
@   int e = -1; int k = 1;
@   while(a>=0) { a-=k; k+=2; e++; } return e;
@ }
M Négyzetgyökvonás lefelé kerekítve.
X -----------------------------------------------------------------------------
F33 Mit ír ki az alábbi program?
@ int main(){
@   int x=1, y, z=(x=$u1, y=x+3);
@   printf("%d", z);
@ }
M A vesszőoperátorral elválasztott kifejezés balról jobbra 
@ értékelődik ki, és az eredmény értéke és típusa megegyezik a legutolsó 
@ (jobb oldali) kifejezésével.
X -----------------------------------------------------------------------------
K Helyes-e az alábbi függvény és valóban a megkapott sztring hosszát írja-e ki?
@ int strlen( char s[] ){
@    int i;
@    for( i = 0; s[i] != 0; i++ );
@    return i++;
@ }
J Helyes a kód és a hosszt is jól számolja
R Hibás a kód, mert nem adhatjuk vissza a lokálisan létrehozott változót.
R A kód helyes, de nem adja vissza pontosan a sztring hosszát.
X -----------------------------------------------------------------------------
K s egy char[] típusú változó, amit a billentyűzetről olvastunk be.
@ Hogyan érdemes kiíratni?
R printf(s);
J printf("%s", s);
R Mindkét megoldás egyformán jó.
M Az ellenőrizetlen karakterlánc tartalmazhat % vezérlő karaktereket, ami miatt
@ a printf() további paramétereket várna. a "%s" formátumsztring megadásával
@ pontosan azt fogja kiírni, amit szeretnénk.
X -----------------------------------------------------------------------------
K Helyes-e a következő program?
@ int valami(const int* i) { return *i = (*i)+1; }
@ int main(){ int i = 5; printf("%d", valami(&i)); return 0; }
R Igen
R Nem, futási idejű hiba
J Nem, fordítási idejű hiba
M Konstans megváltoztatására tett kísérlet
X -----------------------------------------------------------------------------
K Milyen értéket ad vissza az alábbi függvény?
@
@ int increment(int a){ return a = a + 1; } 
J A paraméterben megadott értéknél eggyel nagyobbat.
R A függvény hibás, mert a paraméter értéke nem változtatható meg.
R A függvény hibás, mert visszatérési érték helyett egy értékadás szerepel
@ a return után.
M A paraméterek változóként használhatóak, és egy kifejezésnek mindig van
@ értéke.
X -----------------------------------------------------------------------------
K Problémát jelent-e, ha a programunk tartalmazza az alábbi két 
@ függvénydeklarációt?
@ int sinus(int i);
@ int sinus(double d);
R Igen, mert a szinusz függvény nem kaphat egészet bemenetként.
J Igen, a C nyelvben a függvényneveknek egyedinek kell lenniük.
R Nem, hiszen a paramétereik különbözősége miatt a fordító számára egyértelműen
@ megkülönböztethetők.
X -----------------------------------------------------------------------------
F65 Mit ír ki az alábbi függvény, ha meno(szoveg) módon hívjuk meg, ahol
@ szoveg definíciója az alábbi: char szoveg[]="$s1" ?
@ void meno(char * s){
@     unsigned i;
@     for(i=0;s[i];i++) {
@       if(i%3){if(s[i]>='A'&&s[i]<='Z') s[i]=s[i]-'A'+'a';}
@       else if(s[i]>='a'&&s[i]<='z') s[i]=s[i]+'A'-'a';
@     }
@     printf("%s\n",s);
@ }
M A 3-mal osztható sorszámú helyeken álló betűket naggyá, a többit kicsivé
@ alakítja, a számokat nem módosítja.
X -----------------------------------------------------------------------------
K Melyik szabványos ANSI C függvény használható képernyőtörlésre?
R clrscr()
R cls()
J Nincs szabványos C függvény a képernyőtörlésre
X -----------------------------------------------------------------------------

X *****************************************************************************
C Enum, tömb, struktúra, sztringek
X *****************************************************************************

X -----------------------------------------------------------------------------
F14 Adott az alábbi értékadás:
@ int a[] = {$u2,29,$u3,$u11,$u4,$u5};
@ Mi az értéke az &a[$u1]-a kifejezésnek?
M &a[N] a tömb N-edik elemének címe, ebből levonjuk a tömb címét, ami egyben a
@ 0. elemének címe, azt az egész értéket kapjuk, ahány tömbelem a két cím közé
@ befér, azaz N-et. Így is fel lehetett volna írni ugyanezt a kifejezést: a+N-a
X -----------------------------------------------------------------------------
F7 Mit ír ki az alábbi függvény, ha az adott gépen egy pointer 4 karakternyi?
@ void meret(char t[$u1]){printf("%u",sizeof(t);}
M Pointerméretet ad.
X -----------------------------------------------------------------------------
F8 Mit ír ki az alábbi függvény, ha az adott gépen egy pointer 4 karakternyi?
@ void meret(){char t[$u1];printf("%u",sizeof(t));}
M a tömb méretét adja.
X -----------------------------------------------------------------------------
K Mennyi d értéke az alábbi felsorolt típusban?
@ enum {a = 7, b = 14, c = 21, d};
J 22, mert ha másként nincs megadva, akkor eggyel nagyobb egy konstans értéke,
@ mint az őt megelőzőé.
R 28, mert az következik a sorozatban.
R Nincs inicializálva, így nem lehet megmondani.
X -----------------------------------------------------------------------------
K Hány darab és milyen elemei lesznek az alábbi tömbnek?
@ double t[] = {1.2, 2.4, 3.6};
J Három darab eleme lesz, azok, amiket felsoroltunk.
R Hibás a tömb definíció, mert nem adtuk meg a tömb méretét.
X -----------------------------------------------------------------------------
K Érvényes-e az alábbi struktúra-definíció és ha igen, milyen adatszerkezetet
@ valósít meg?
@ struct Konyvek {
@    char szerzo[20];
@    char cim[50];
@    int kiadas_eve;
@    struct Konyvek kovetkezo;
@    struct Konyvek elozo;
@ };
J Nem jó a definíció, mert rekurzív a szerkezet.
R Helyes definíció, egy láncolt lista alapelemét írja le.
R Helyes a definíció. Az elnevezéstől függetlenül megvalósítható vele két
@ irányban láncolt lista és bináris fa is.
X -----------------------------------------------------------------------------
K Adott az alábbi értékadás:
@ int a[] = {1,2,3,4};
@ Okoz-e fordítási idejű hibát az a[-1] kifejezés?
J Nem.
R Igen, mert a tömbök indexelése nullával kezdődik.
R Igen, mert a tömbök indexelése eggyel kezdődik.
X -----------------------------------------------------------------------------
K Adottak az alábbi értékadások:
@ int a[] = {1,2,3,4};
@ int* p = a;
@ Okoz-e fordítási idejű hibát a p[6] kifejezés?
J Nem.
R Igen, mert mutató típusú változóhoz egy tömb típusú változót rendelünk
@ értékként, illetve a [] operátorral csak tömbök indexelhetőek.
R Igen, mert túlcímzés történik.
X -----------------------------------------------------------------------------
K Mit ír ki a következő kód?: char *s="abcdef"; printf("%d", sizeof(s));
R 6, mert hat betűt tartalmaz a sztring.
R 7, mert hat betű, és a lezáró nulla karakter a sztring mérete.
J A számítógép típusától függ.
M A sizeof operátor itt egy pointer méretét adja vissza, mert s egy karakterre
@ mutató pointer. Nem pedig a sztring hosszát, se nullával, se anélkül.
X -----------------------------------------------------------------------------
K Teljesül a feltétel az alábbi kódban?
@ char s[] = "Hello!", t[] = "Hello!";
@ if(s == t) printf("A két sztring egyforma!");
R Igen.
J Nem.
M Bár a két sztringben ugyanaz a karaktersorozat szerepel, a rájuk mutató
@ pointerek nem egyformák. Az == operátor azt hasonlítja össze, nem pedig a
@ tartalmukat. A tartalom összehasonlításához az strcmp()-t kell használni.
X -----------------------------------------------------------------------------
K Teljesül a feltétel az alábbi kódban?
@ char s[] = "Hello!", t[] = "Hello!";
@ if(strcmp(s, t)) printf("A két sztring egyforma!");
R Igen.
J Nem.
M Az strcmp() visszatérési értéke egy egész szám, amely egyezés esetén 0,
@ egyébként pedig pozitív vagy negatív számmal tér vissza, attól függően, hogy
@ melyik paraméter van előbb betűrendben. Ha összehasonlítunk két sztringet,
@ a helyes forma: if (strcmp(s, t)==0) printf("Egyformák!");
X -----------------------------------------------------------------------------
K 10 darab, képernyőn pattogó labda koordinátáit szeretnénk tárolni. Melyik
@ a javasolt kódolási technika?
@ A: int golyo_x[10], golyo_y[10];
@ B: struct golyo{ int x; int y; };
@    struct golyo golyok[10];

R Az A, mert sokkal egyszerűbb.
R Mindkettő.
J A B, mert kifejezi a koordináták összetartozását.
X -----------------------------------------------------------------------------
K Melyik állítás igaz?
R Függvények hívásakor mindig fel kell tüntetni a paraméterek típusát.
R A függvények a tömböket érték szerint veszik át.
J A függvények a struktúrákat érték szerint veszik át.
X -----------------------------------------------------------------------------
K Válassza ki a hamis állítást! (A tömb elemeit 0-tól számozzuk)
R Az 'a' tömb i. elemét *(a+i) módon is elérhetjük
R Az 'a' tömb i. elemének címe a+i
J Ha 'a' egy tömb akkor az a++ művelet a 2. elem címét adja vissza.
X -----------------------------------------------------------------------------
K Rekurzív struktúrát akarunk létrehozni. Mit kell a ??? helyére írni?
@ typedef  struct s { ??? p; int e; } str;
J struct s *
R str *
R struct * s
X -----------------------------------------------------------------------------
F27 Mit ír ki az alábbi program?
@ #include <stdio.h>
@ typedef enum {hetfo, kedd, szerda, csutortok, pentek, szombat, vasarnap} napok;
@ napok nap = $u1 % 7;
@ void main(void) {nap = (nap +  kedd) % 7; printf("%d", nap);}
X -----------------------------------------------------------------------------
K Mit tartalmaz a char s[] = "Nem értem" sztring változó, ha meghívtuk a
@ shuf(s) függvényt?
@ void shuf(char *trs) {
@     int i;
@    for (i = 0; trs[i] && trs[i+1]; i += 2) {char c = trs[i]; trs[i]=trs[i+1]; trs[i+1]=c;}
@ }
J Felcseréli az egymást követő betűket: "eN mréetm"
R Minden második betű helyére az őt követőt teszi: "ee  ééttm"
R Beugratós a feladat: a változó értéke nem változik meg, hiszen a C-ben a függvények nem tudják 
@ megváltoztatni a paraméterként kapott változók értékét.
X -----------------------------------------------------------------------------
F28 Mit ír ki a program?
@ int a[] = {2, 0, 0, 8};
@ void main(void) {printf("%d", $u1 % 2 ? a[1] : a[3]);}
M A szám páros/páratlan voltától függően 8-at vagy 0-t.
X -----------------------------------------------------------------------------
F34 Mit ír ki az alábbi program?
@ #define SIZE $u1
@ void main(){
@   double x[SIZE], *fp; int i;
@   for (i = 0; i < SIZE; i++){ x[i]=0.5*(double)i; fp=x; }
@   printf("%f", *(fp+i-1));
@ }
X -----------------------------------------------------------------------------
K Helyesen működik-e az alábbi program?
@ #include <stdio.h>
@ void main(){ double x=3.14, y; int *p;  p = &x; y = *p;  printf("%f",y);}
J Nem
R Igen
M int pointer lebegőpontosra mutat, a másolás is hibás
X -----------------------------------------------------------------------------
K Mit ír ki az alábbi program?
@ main(){
@   char word[20]; word[0] = 'B'; word[1] = 'Y';
@   word[2] = 'E'; word[3] = 0; word[4] = 'B';
@   printf("The contents of word[] is -->%s\n", word);
@ }
J The contents of word[] is --> BYE
R The contents of word[] is --> BYE B
R The contents of word[] is --> BYE0B
X -----------------------------------------------------------------------------
K Mit ír ki az alábbi program?
@ main(){
@   char word[20];
@   word[0] = 'B'; word[0]++;
@   word[1] = 'Y';
@   word[2] = 'E'; --word[2];
@   word[3] = 0;
@   word[4] = 'B';
@   printf("The contents of word[] is -->%s\n", word);
@ }
R The contents of word[] is --> BYE
R The contents of word[] is --> BYD
J The contents of word[] is --> CYD
X -----------------------------------------------------------------------------
F39 Mennyi lesz a következő enumban c értéke?
@ enum {a = $u1, b = $u2, c};
X -----------------------------------------------------------------------------
K Helyes-e az alábbi kódrészlet?
@ int i;
@ double t[5];
@ for( i = 1; i <=5; i++ ){
@    printf("\nt[%d]", i );
@    scanf("%lf", &t[i]);
@ }
R Igen.
J Nem, mert kiindexelünk a tömbből
X -----------------------------------------------------------------------------
F44 Mennyi lesz x értéke?
@ int t[] = {$u1, 62, $u2, $u3, 32, 157}
@ int *p = t + 2;
@ int x = p[1];
M A mutatók és tömbök hasonlóan használhatók, a p mutató t[2]-re mutat, 
@ egyenlő &t[2]-vel, p[1] pedig egyenértékű *(p+1)-gyel, ami t[3] lesz,
@ melynek értéke $u3.
X -----------------------------------------------------------------------------
K Helyes-e a következő változó definiálás és értékadás?
@      char t[] = "Hello";
J Igen
R Nem
X -----------------------------------------------------------------------------
K Helyes-e a következő változó definiálás és értékadás?
@      char t1[10]; t1 = "Hello";
J Nem
R Igen
X -----------------------------------------------------------------------------
F53 Mit ír ki a következő programrészlet?
@    char str[] = "$s1";
@    char *p = str;
@    while (*p){
@        if (*(p+1)) *p = *(p+1);
@        p++;
@    }
@    printf("%s", str);
X -----------------------------------------------------------------------------

K Adott az alábbi értékadás: char s[]="Hello!";
@ Okoz-e fordítási idejű hibát a s[6] kifejezés?
R Nem, olvasni bárhonnan lehet a memóriából, csak írásnál gond a túlcímzés.
J Nem, futásidőben a lezáró '\0'S karakter kapjuk vissza.
R Igen, mert túlcímzés történik.
X -----------------------------------------------------------------------------
K Mi történik, ha a konzolon a "Juliska" szöveget gépeljük be, miután
@ elindítottuk az alábbi programot?
@
@ int main(){
@    char nev[7];
@    scanf("%s", nev);
@    printf("%s", nev);
@    return 0;
@ } 
R Juliska íródik ki.
R Julisk íródik ki.
J A sztring nem fér bele a tömbbe, ami a program elszállását vagy hibás
@ működését is okozhatja, de a hiba nem feltétlenül jelentkezik.
X -----------------------------------------------------------------------------
K Hány darab és milyen elemei lesznek az alábbi tömbnek?
@ int k[3]={1,2,3,4};
R Négy darab eleme lesz, azok, amiket felsoroltunk.
R Három darab eleme lesz, az első három a felsoroltak közül.
J Hibás a tömb definíció, mert több inicializálási értéket adtunk meg mint
@ a tömb elemszáma
X -----------------------------------------------------------------------------
K Mekkora egy struktúra mérete?
J Legalább akkora, mint a benne lévő adatok összmérete.
R Pontosan akkora, mint a benne lévő adatok összmérete.
R Nagyobb, mint a benne lévő adatok összmérete, mert a rendszer eltárolja a
@ struktúra leírását is a struktúrában.
M Nincs benne egyéb hasznos adat, viszont töltelékadat lehet 
X -----------------------------------------------------------------------------
K Mi az strlen(s) == strlen(&s[0]) kifejezés értéke, ha char *s = "sztring";
J Igaz
R Hamis
X -----------------------------------------------------------------------------
K Van-e különbség az alábbi két sor között?
@ char str[] = "alma";
@ char *str = "alma";
R Nincs különbség.
J Van különbség a memória kezelésében.
R Van különbség az str változó kiíratásában.
M Az első esetben egy 5 méretű karaktertömb jön létre, míg a másik esetben 
@ egy mutatót állítunk a konstans sztringre.
X -----------------------------------------------------------------------------
K Mit lesz a size változó értéke?
@ char *msg = "Hello";
@ size_t size = sizeof(msg)/sizeof(char);
R 5
R 6
J rendszerfüggő
X -----------------------------------------------------------------------------
K Ha egy tömböt adunk át paraméterként egy függvénynek, és a függvényben
@ szeretnénk változtatni a tömb tartalmán, akkor szükséges-e az & operátor?
J Nem, mert a tömb neve a tömb első elemére mutató pointer.
R Igen, hiszen mindig kell az & operátor ha egy változót meg akarunk
@ változtatni egy függvényen belül.
R A tömb tartalmát nem lehet megváltoztatni a paraméterlistán keresztül.
X -----------------------------------------------------------------------------
K Mikor adja meg a sizeof operátor a tömb méretét?
J Csak abban a blokkban, ahol definiálva van (hacsak nem globális).
R Mindig.
R Ahol definiáltuk attól kezdve mindig, függvényekben is.
X -----------------------------------------------------------------------------
K Lehet-e egy függvény visszatérési értéke egy struktúra?
J Igen
R Nem, csak a rá mutató pointer
R Nem, a visszatérési érték csak alaptípus lehet
X -----------------------------------------------------------------------------
F71 Adott az alábbi értékadás:
@ int t[] = {$u1, $u2,  $u3,  2, $u4, $u5};
@ Mi az értéke a (t+2)[t[3]+1] kifejezésnek?
X -----------------------------------------------------------------------------
K Hogyan viszonyul egymáshoz sizeof(struct polip1) és sizeof(struct polip2)?
@ struct polip1{ char kar[8]; double szem; };
@ struct polip2{ char kar1[6]; double szem; char kar2[2]; };
R Egyenlők, hiszen ugyanakkorák külön-külön az adattagok mindkét struktúrában.
R sizeof(struct polip2) 1-gyel nagyobb, mert ott két karaktertömbhöz is 
@ tartozik egy lezáró '\0'.
J Rendszer- ill. fordítófüggő; eltérhetnek.
M Nem biztos, hogy szorosan egymás mellé kerülnek a tagok, hanem bizonyos 
@ tagok kezdőcímét az adatbusz szélességének többszörösére pozícionálja a 

@ fordító, hatékonyság végett. (Próbáld ki a példát Ural2-n!)
X -----------------------------------------------------------------------------
K Mit mondhatunk a következő kódrészletről?
@        char str[]="alma"; char* p; p = str;
R A p = str értékadás hibás, mert az egyik pointer, a másik tömb.
R A p által mutatott területre átmásolja az "alma" sztringet,
@ de mivel a p még nem kapott értéket, ezért a program valószínűleg
@ el fog szállni.
J A p pointer az "alma" sztringre fog mutatni.
X -----------------------------------------------------------------------------
K Mit eredményez az alábbi program?
@ #include <stdio.h>
@ typedef enum {januar=1, februar, marcius, telho=1, teluto, tavaszelo} honapok;
@ void main(void){
@     honapok kedvencem = marcius;
@     printf("februar a %d. honap, tavaszelo a %d., kedvencem a %d.\n",
@       februar, tavaszelo, kedvencem);
@     getchar(); return;
@ }
J februar a 2. honap, tavaszelo a 3., kedvencem a 3.
R februar a februar. honap, tavaszelo a tavaszelo., kedvencem a marcius.
R Nem fordul le: két különböző szimbólum azonos sorszámhoz a felsorolásban.
X -----------------------------------------------------------------------------
K Péter a következő kódrészben a 'b' tömbbe át akarja másolni az 'a' tömb
@ tartalmát, addig amíg nullát nem talál (a nullát is), de maximum csak annyit,
@ ami a 'b' tömbbe belefér. A kapkodásban a while ciklus logikai kifejezésébe
@ && helyett & került.
@ Mit mondhatunk a következő kódrészletről?
@       int a[10]={8,9,10,11,12,13,14,15,16,0}, b[5], i=0;
@       while( i<5 & ( (b[i]=a[i]) != 0) ) i++;
R Nem baj, így is jól fog működni a ciklus, mert az & jobb és bal oldalán is
@ logikai kifejezés áll, és a ciklusban maradás feltétele IGAZ & IGAZ érték is
@ IGAZ, ha pedig valamelyik oldal értéke hamis, akkor a teljes kifejezés
@ értéke is hamis.
R A program nem fordul le, mert a bitenkénti ÉS kapcsolat
@ csak egész típusokra értelmezett.
J A kód nem működik helyesen, mert i==5 esetén is átmásolja az a[i] értékét a
@ b[i]-be, tehát túlcímzi a 'b' tömböt.
M Amikor i==5, akkor a b[i]=a[i] kód is lefut, hiszen az & előtt álló
@ kifejezés IGAZ vagy HAMIS volta nem befolyásolja azt, hogy az & utáni
@ kifejezés kiértékelődik-e, ellentétben az && operátorral.
X -----------------------------------------------------------------------------


X *****************************************************************************
C Keresés, rendezés, hashing
X *****************************************************************************

X -----------------------------------------------------------------------------
K Mi a bináris keresés alkalmazhatóságának feltétele?
R A tömb mérete kettő valamely hatványa kell legyen.
J A tömb elemei rendezve kell legyenek.
R A bináris keresés csak számokon alkalmazható.
X -----------------------------------------------------------------------------
K Végezhető-e bináris keresés olyan tömbön, amelyben az elemek fordított
@ sorrendben szerepelnek?
J Igen.
R Nem.
X -----------------------------------------------------------------------------
K Melyik rendezést valósítja meg az alábbi programkód?
@ int i,j,minindex;
@ for(i=0;i<meret-1;i++){
@   minindex=i;
@   for(j=i+1; j<meret; j++) if(t[j] < t[minindex]) minindex =j ;
@   if(minindex!=i){
@      double temp = t[minindex]; 
@      t[minindex]=t[i]; 
@      t[i]=temp;
@   }
@ }
J Közvetlen kiválasztásos.
R Közvetlen beszúrásos.
R Buborék.
X -----------------------------------------------------------------------------
K Milyen irányban rendezi a tömböt az alábbi algoritmus?
@ void h(int *t, int s) {
@   int i, j;
@   for(i=s-1; i>=0 ;i--)
@     for(j=i-1; j>=0; j--)
@       if(t[i]<t[j]){
@         int k = t[i];
@         t[i] = t[j];
@         t[j]=k;
@       }
@ }
J Növekvő.
R Csökkenő.
X -----------------------------------------------------------------------------
K Az alábbiak közül melyik a legkevésbé hatékony?
J Buborékrendezés
R Bináris fa rendezés
R Gyorsrendezés
X -----------------------------------------------------------------------------
K n adat esetén milyen nagyságrendű a gyorsrendezés átlagos lépésszáma?
J n*logn
R logn
R n*n
X -----------------------------------------------------------------------------
K n adat esetén milyen nagyságrendű a buborékrendezés átlagos lépésszáma?
R n*logn
R logn
J n*n
X -----------------------------------------------------------------------------
K Hash tárolási technikát alkalmazva listázhatóak-e sorrendhelyesen a táblában
@ tárolt adatok?
J További rendezés nélkül nem.
R Igen.
X -----------------------------------------------------------------------------
K Igaz vagy hamis: a hash-eléshez használt adatstruktúra csak tömb lehet?
J Hamis.
R Igaz.
X -----------------------------------------------------------------------------
K A hash technikán alapuló tárolási elv átlagos lépésszáma beszúrás esetén
@ (megfelelően nagy táblaméret mellett) ...
J konstans.
R arányos az adathalmaz méretével.
R arányos az adathalmaz méretének négyzetével.
X -----------------------------------------------------------------------------
K A hash technikán alapuló tárolási elv átlagos lépésszáma keresés esetén
@ (megfelelően nagy táblaméret mellett) ...
J konstans.
R arányos az adathalmaz méretével.
R arányos az adathalmaz méretének négyzetével.
X -----------------------------------------------------------------------------
K A hash technikán alapuló tárolási elv átlagos lépésszáma közel telített
@ táblában való keresés esetén ...
J arányos az adathalmaz méretével.
R konstans.
R arányos az adathalmaz méretének négyzetével.
X -----------------------------------------------------------------------------
K Milyen műveletek lesznek hatékonyak hashing alkalmazásával?
J Keresés, beszúrás, törlés és módosítás
R Keresés, beszúrás, rendezés és törlés
R Keresés, beszúrás, min-max kiválasztás és módosítás
X -----------------------------------------------------------------------------
K Melyik rendezést valósítja meg az alábbi programkód?
@ int i,j,buf;
@ for(i=0;i<n;i++){
@   buf=a[i]; j=i-1; 
@   while(j>0 && buf<a[j]){ a[j+1]=a[j]; j=j-1; }
@   a[j+1]=buf;
@ }
R Közvetlen kiválasztásos.
J Közvetlen beszúrásos.
R Buborék.
X -----------------------------------------------------------------------------
K Melyik rendezést valósítja meg az alábbi programkód?
@ int i,j,t;
@ for(i=0;i<n-1;i++){
@   for(j=0;j<n-i-1;j++)if(a[j]>a[j+1]){ t=a[j]; a[j]=a[j+1]; a[j+1]=t; }
@ }
R Közvetlen kiválasztásos.
R Közvetlen beszúrásos.
J Buborék.
X -----------------------------------------------------------------------------
K Lehet-e egy egyirányú láncolt listában binárisan keresni?
R Igen, bármikor
R Igen, de csak akkor ha az rendezett
J Nem lehet, mert mindig csak a következő elemre lehet ugrani.
X -----------------------------------------------------------------------------
K Milyen adatszerkezeten végezhető el a gyorsrendezés?
J tömbökön
R egy irányban láncolt listán
R mindkettőn
X -----------------------------------------------------------------------------
K Milyen adatszerkezeten végezhető el a gyorsrendezés?
R tömbökön
R két irányban láncolt listán
J mindkettőn
X -----------------------------------------------------------------------------
K Milyen adatszerkezeten végezhető el a buborékrendezés?
R tömbökön
R egy irányban láncolt listán
J mindkettőn
X -----------------------------------------------------------------------------
K Mitől lassú a buborékrendezés?
J Ha egy elem nagyon messze van a végleges helyétől, sok lépésben kell
@ cserélgetni
R Mivel a rendezett szakasz hossza lépésenként csak egyesével nő
M A hatékonyság javítható, hogy ha megjegyezzük az utolsó csere helyét, akkor
@ a rendezett szakasz nem csak egyesével nőhet
X -----------------------------------------------------------------------------
K A gyorsrendezés azért gyors, mert...
R ötvözi a buborék algoritmus és a közvetlen kiválasztás előnyeit.
J egyszerű lépésekkel hamar a végleges helyük közelébe mozgatja az elemeket.
R egyszerre több helyen, párhuzamosan rendezgeti a tömböt.
X -----------------------------------------------------------------------------
K Egy int t[100] rendezetlen tömbben a minimális elemet keressük,  
@ milyen kezdőértéket kell adni a minimumot tároló változónak?
R Nem kell kezdőérték
R -65535
J A tömb egyik elemére állítsuk be.
X -----------------------------------------------------------------------------

X *****************************************************************************
C Függvényérték paramétersoron, függvénypointer, rekurzió
X *****************************************************************************

X -----------------------------------------------------------------------------
F42 Mi lesz az fv($u1) hívás eredménye?
@ int fv(int n) {
@   if (n <= 1 ) return n;
@   return fv(n - 1) + fv(n - 2);
@ }
M A függvény az n-edik Fibonacci számot számolja ki rekurzívan.
@ fv(0)=0, fv(1)=1, fv(2)=1, fv(3)=2, fv(4)=3, fv(5)=5.
@ Ez a megvalósítás nagyon nem hatékony, mert exponenciális futási idejű.
@ A hatékony megoldás egy ciklust használna dupla rekurzió helyett.
X -----------------------------------------------------------------------------
F43 Mit ír ki az alábbi program?
@ int cnt = 0;
@ int fv(int n) {
@   cnt++; if (n <= 1) return n;
@   return fv(n - 1) + fv(n - 2);
@ }
@ void main() { int a = fv($u1);  printf("%d", cnt); }
M A függvény az n-edik Fibonacci számot számolja ki rekurzívan.
@ fv(0)=0, fv(1)=1, fv(2)=1, fv(3)=2, fv(4)=3, fv(5)=5.
@ A cnt változó azt számolja össze, hogy az fv függvény hányszor lett meghívva.
@ fv(0) és fv(1) kiszámolásához 1-1 hívás kell, fv(2)-höz 1+1+1=3,
@ fv(3)-hoz 1+3+1=5, fv(4)-hez 1+5+3=9, aztán 1+9+5=15, 1+15+9= 25, stb. 
@ Ez a megvalósítás nagyon nem hatékony, mert exponenciális futási idejű, ezt
@ a kapott eredményekből is láthatjuk.
@ A hatékony megoldás egy ciklust használna dupla rekurzió helyett.
X -----------------------------------------------------------------------------
K Meghívható-e a main() függvény egy C programból?
R Nem, mert az rekurzióhoz vezetne, ahol fennáll a végtelen ciklus veszélye.
J Igen.
R Nem, mert nem tudjuk behelyettesíteni az argc, argv paramétereket.
X -----------------------------------------------------------------------------
K Mit lesz az "a" változó értéke?
@ int g (unsigned i) { printf("%d\n", i); return i ?  g(i-1) : 0; }
@ //...
@ a = g(10);
J 0, mert a legkülső hívás ebben a rekurzióban mindig 0-val tér vissza.
R 9, mert i = 10-el lett meghívva a függvény, és 10 nem egyenlő nullával,
@ tehát 10 - 1 = 9 lesz a visszatérési érték.
R Nem lehet megmondani, mert a függvény örökké saját magát hívogatja, amíg
@ le nem állítják.
X -----------------------------------------------------------------------------
F9 Mit ír ki az alábbi program?
@ #include <stdio.h>
@ void dinoszaurusz(int i){i=3*i+1;}
@ int main(){
@    int x=$u1;
@    dinoszaurusz(x);
@    printf("%d\n",x);
@    return 0;
@ }
X -----------------------------------------------------------------------------
F10 Mit ír ki az alábbi program?
@ #include <stdio.h>
@ void dinoszaurusz(int * i){*i=3*(*i)+1;}
@ int main(){
@    int x=$u1;
@    dinoszaurusz(&x);
@    printf("%d\n",x);
@    return 0;
@ }
X -----------------------------------------------------------------------------
K A C nyelvben csak érték szerinti paraméterátadás létezik. Hogy írhatnánk 
@ mégis olyan függvényt, amely megváltoztatja a paraméter értékét? 
J Pointerekkel.
R Sehogy.
X -----------------------------------------------------------------------------
K Mi történik az alábbi programban?
@ void k(void *t, int st, int se, void(*f)(void *)) {
@    int i=0;
@    for(; i < st; i++)
@      f((char *)t + (i * se));
@ }
@ void j(void *k){
@    int t = *((int *)k);
@    printf("%d ", t);
@ }
@ void main(void){ int t[] = {23, 12, 45, 67, 89};
@    k(t, sizeof(t)/sizeof(int), sizeof(int), j);
@ }
J A program kiírja a t tömb elemeit sorban a képernyőre. A k függvény egy tet-
@ szőleges tömb minden elemére meghívja a paraméterként kapott f függvényt.
@ A j függvény egy void*-ként kapott, int-re mutató pointer alapján kiírja az
@ adott címen lévő egész számot.
R A program rendezi a tömböt és kiírja az elemeit. A k függvény közvetlen kivá-
@ lasztásos módszerrel rendezi a tömböt a j függvény pedig kiírja az elemeit.
X -----------------------------------------------------------------------------
K Mi f típusa az alábbi deklarációban?
@ int (*f)(const void*, const void*)
J Egy olyan függvény címe, amely két mutatót vár és egy egész értéket ad vissza.
R Egy olyan függvény címe, amely két mutatót vár és egy egész mutatót ad vissza.
X -----------------------------------------------------------------------------
K Adott az alábbi függvénydeklaráció:
@ void qsort( void* base, int numel, int width, int (*comp)(const void*, const
@ void*) );
@ A qsort függvény hívásakor átadható-e negyedik paraméterként egy
@ int* compare(void*, void*);
@ szignatúrával rendelkező függvény?
R Nem.
J Igen, de a program viselkedését nem tudjuk előre megmondani.
M A compare függvény egész értékekre irányított mutatót ad vissza, míg qsort
@ negyedik paramétere egész visszatérési értékű függvényt vár. Ezenfelül a
@ const megszorítás miatt a qsort paramétereként átadott függvénynek garantál-
@ nia kell, hogy a számára megadott területen található értékeket változatlanul
@ hagyja. Ezt a megadott compare függvény nem vállalja.
X -----------------------------------------------------------------------------
K Melyik függvényhívási mód helyes?
@ void function (int a) { }
@ void (*pfunction)(int) = function;
@ A: pfunction(2);
@ B: (*pfunction)(2);
J Mindkettő
R Csak az A
R Csak a B
X -----------------------------------------------------------------------------
K Mikor célszerű függvénypointert használni?
J Ha szeretnénk a megvalósító algoritmust dinamikusan kiválasztani.
R Ha szeretnénk elbonyolítani a kódot.
X -----------------------------------------------------------------------------
F26 Mit ír ki a Main függvény, ha így hívjuk: Main(Int)?
@ #include <stdio.h>
@ int Int(int i){if (i) i*=Int(i-1); return i;}
@ void Main(int(*maIn)(int)){int x=$u1; printf("%d\n",maIn(x));}
M Mindig nullát ad vissza.
X -----------------------------------------------------------------------------
K void f(int *p, int m){*p=m;}
@ void main(){int a=0,b=5; f(&a,b);printf("a erteke: %d, b erteke: %d\n",a,b);}
R a erteke: 0, b erteke: 5
J a erteke: 5, b erteke: 5
R a erteke: 0, b erteke: 0
X -----------------------------------------------------------------------------
K Helyes-e a következő kód? char s[211]; scanf("%s",s)
J Igen, mert a %s-sel olvassuk be, és a tömb mindig cím szerint adódik át.
R Nem, mert nem s címét adtuk meg.
R %s-sel nem is lehet beolvasni adatot.
X -----------------------------------------------------------------------------
F47 Adott az alábbi függvénydefiníció:
@ int f(int n, int a, int b) { 
@    if (n > 2)return f(--n, a+b, a);
@    return a;
@ }
@ Mi az f($u1, 1, $u2); függvényhívás eredménye? 
X -----------------------------------------------------------------------------
F48 Adott az alábbi függvénydefiníció:
@ int f(int n, int a, int b){ 
@    if (n > 2)return f(--n, a+b, a);
@    return a;
@ }
@ Mi az f($u1, $u2, 1); függvényhívás eredménye?
X -----------------------------------------------------------------------------
F49 Tekintse a következő függvénydefiníciót:
@ int f(unsigned i, unsigned a, unsigned b) {
@     if (i > 1)return f(i-1, b, a+b);
@     else return b;
@ }
@ Mi az f($u1, $u2, $u3) függvényhívás eredménye?
X -----------------------------------------------------------------------------
F50 Tekintse a következő függvénydefiníciót:
@ int f(unsigned i, unsigned s) {
@     if (i > 0) return f(i-1, i+s);
@     else return s;
@ }
@ Mi az f($u1, $u2) függvényhívás eredménye?
X -----------------------------------------------------------------------------
F51 Tekintse a következő függvénydefiníciót:
@ int f(const char* s, unsigned i, unsigned n) {
@     if(*s)return f(s+1, i+1, *s >= 'A' && *s <= 'Z' ? i+n : n);
@     else return n;
@ }
@ Mi az f("$s1", $u1, $u2) függvényhívás eredménye?
X -----------------------------------------------------------------------------
K Melyik a helyes definiálása egy függvénypointernek, amelynek void * vissza-
@ térési értéke van, és két double-t vár paraméterként?
J void * (*f)(double, double);
R void * f(fouble, double);
R f(double, double) void*;
X -----------------------------------------------------------------------------
K Működőképes-e az alábbi függvény?
@
@ char *f(){char nev[30];printf("Ird be a neved!");scanf("%s",nev);return nev;}
R Igen
R Nem, mert pointert kellene visszaadnia, de tömböt ad vissza
J Nem, mert a visszaadott pointer nem megfelelő helyre mutat
M A lokális változók memóriaterülete csak a függvényen belül használható.
X -----------------------------------------------------------------------------
K Mit ír ki a program?
@ int a(void){return 1;}
@ int b(void){return 2;}
@ void main(void){
@   int (*fgv[2])()={a,b},i=1;
@   printf ("%d\n",fgv[--i]());}
J 1
R 2
X -----------------------------------------------------------------------------
K Mi okozza a fordítási idejű hibát?
@ float plus    (float a, float b) { return a+b; }
@ float minus   (float a, float b) { return a-b; }
@ float operation(float, float);
@ float evaluate(float a, float b, operation o) { return o(a,b); }
@ void main() { printf("%f", evaluate(1,2, plus)); }
J A typedef kulcsszó hiánya az operation előtt
R Az evaluate függvény hívásakor a plus elé kell a cím operátor
R Az evalute függvényben található o függvényhívásnál az indirekció operátort
@ kell használni
X -----------------------------------------------------------------------------
K Milyen tömböket lehet rendezni a szabványos könyvtárból elérhető
@ gyorsrendezéssel (qsort)?
J Bármilyet, de meg kell adni az elemek méretét és az összehasonlítást végző
@ függvény mutatóját.
R Csak beépített típusokat tartalmazó tömböket.
R Bármilyet, de beépített típusok esetén nem kell megadni az összehasonlítást
@ végző függvény mutatóját.
X -----------------------------------------------------------------------------
K Írható-e elvben olyan függvény, amely deklarációjában nem szerepel
@ a '*' karakter, mégis megváltoztatja a paraméter értékét?
R Nem, a C nyelvben csak érték szerinti paraméterátadás létezik, így
@ pointert kell átadni, amihez muszáj '*'-ot használni valahol.
J Igen, például sort(int t[], int n);
X -----------------------------------------------------------------------------
K Mit ír ki a következő program?
@ void afunction(int *x){ *x=12; }
@ int main(){ int v=10; afunction(&v); printf ("%d",v); return 0; }

R 10
J 12
R v változó címét
X -----------------------------------------------------------------------------  
F72 Mit ír ki a program?
@ void csere(int x, int y){ int b; b=x; x=y; y=b; }
@ int main(){ int a=$u1,b=$u2; csere(a,b); printf("%d\n",b); return 0; }
M Érték szerinti paraméterátadás történik; 'a' és 'b' értéke változatlan marad.
@ A csere() függvényen belüli 'b' változó pedig teljesen független a main() 
@ függvényben levőtől!
X -----------------------------------------------------------------------------  
K Mit csinál a következő függvény ?
@ long convert( char s[] ) {
@        long result, r2;
@        for( result = 0L; *s; s++) {
@                if( *s >='0' && *s <='9' ) {
@                        result = (r2 = result << 1) << 2;
@                        result += *s -'0' + r2;
@                }
@                else return result;
@        }
@        return result;
@ }
R Összeadja az s sztringben lévő decimális számjegyeket
R A result = (r2 = result << 1) << 2 kifejezés nem jól definiált, ezért a
@ convert függvény visszatérési értéke fordítófüggő.
J Az atol függvényhez hasonlóan, egy decimális számjegyeket tartalmazó
@ sztringet long értékké konvertál.
X -----------------------------------------------------------------------------
K Mit ír ki a következő függvény, ha az egész 32 bites, és a negatív számok
@ kettes komplemens kódban vannak ábrázolva?
@ void f() {
@        int i; i=-2;
@        if( i>(-1)) printf("X"); else if(i<10) printf("Y");
@        printf("%x%d\n", i+1, i-1);
@ }
J Yffffffff-3
R X-1-3
R Y-1-2
X -----------------------------------------------------------------------------
K Átalakítható-e egy ciklussal megadott programrészlet úgy, hogy abban a
@ ciklust önhivatkozó (rekurzív) függvényhívás helyettesítse?
J Igen.
R Nem minden esetben.
M Az átalakítás során a ciklusváltozóból és a törzsben szereplő
@ gyűjtőargumentumokból függvényparaméterek lesznek. Az átalakítás módját az
@ alábbi, egy pozitív n szám faktoriálisát kiszámító kódrészletet illusztrálja.
@ int p = 1, i;
@ for (i = n; i > 0; i--) {
@     p *= i;
@ }
@ Ugyanez önhivatkozó függvényhívás segítségével:
@ int fact(int p, int i) {
@     if (i > 0) {
@             return fact(p*i, i-1);
@         } else {
@             return p;
@         }
@ }
@ ahol a faktoriális számítását a fact(1, n) hívás indítja.
X -----------------------------------------------------------------------------
K Mire használható a va_arg makró?
R Változó paraméterszámú függvényekben az argumentum pointer inicializálásához
R "Rendet rak" egy változó hosszúságú paraméterlistával rendelkező függvényből
@ való visszatérés előtt
J Ezzel léphetünk tovább a következő azonosító nélküli argumentumra
X -----------------------------------------------------------------------------
K Mit ír ki a program?
@ main(int argc, char ** argv) { printf("%s",argv[2]); return 0; }
J A program 2. paraméterét
R A program paramétereinek számát.
R A program 3. paraméterét
X -----------------------------------------------------------------------------
K Mit ír ki a program?
@ main(int argc, char ** argv) { printf("%d\n", argc); return 0; }
R A program 2. paraméterét
J A program paramétereinek számát.
R A program 3. paraméterét
X -----------------------------------------------------------------------------
K Mit jelent az, ha egy globális változó statikus?
J A változó nem érthető el más forrásállományokból.
R A változó a program futása után is a memóriában marad és megőrzi értékét.
R A változót kötelező inicializálni.
X -----------------------------------------------------------------------------
K Mit jelent az, ha egy lokális változó statikus?
R A változó nem érthető el más forrásállományokból.
J A változó a blokk befejeződése után is megőrzi értékét
R A változót kötelező inicializálni.
X -----------------------------------------------------------------------------
K Mit ír ki a program?
@ #include<stdio.h>
@ int main(int argc, char ** argv){
@   if (!strcmp(argv[0],"fritillaria")) 
@     printf("Szojuz T-10\n");
@   return 0;
@ }
J Ha a futtatható programállomány neve "fritillaria", akkor azt, hogy 
@ "Szojuz T-10", különben semmit.
R Ha első paraméterként azt adtuk meg, hogy "fritillaria", akkor azt, hogy 
@ "Szojuz T-10", különben semmit.
R Azt, hogy "Szojuz T-10".
X -----------------------------------------------------------------------------
K Melyik main() deklaráció helyes az alábbiak közül?
@ A int main();
@ B int main(int argc);
@ C int main(int argc, char *argv[]);
J Mindhárom helyes
R Csak A és C
R Csak A

X *****************************************************************************
C Pointerek, dinamikus adatszerkezetek
X *****************************************************************************

X -----------------------------------------------------------------------------
K Szintaktikailag típushelyes-e az alábbi utasítás?
@ **p = 25;
J Igen, amennyiben p egy egész mutatókra irányított mutató.
R Igen, amennyiben p egy egész mutató.
R Nem.
X -----------------------------------------------------------------------------
K Melyik utasítás helyes?
J double * d=(double*)malloc(100*sizeof(double));
R double * d=(double*)calloc(100*sizeof(double));
R double * d=(double*)malloc(100,sizeof(double));
X -----------------------------------------------------------------------------
K Mi történik, ha túl sok memóriát próbálunk foglalni a malloc függvénnyel?
R Az operációs rendszer megszakítja a program futását.
J NULL értéket kapunk vissza.
R Annyi memóriát foglal, amennyi rendelkezésre áll.
X -----------------------------------------------------------------------------
K Adott az alábbi struktúra. Milyen dinamikus adatszerkezetet épít belőle az
@ adott függvény?
@ struct a {int b;struct a *c;struct a *d;};
@ struct a *ad(struct a *e, int f) {
@   struct a *g = (struct a *)malloc(sizeof(struct a)), *h;
@   g->b = f; g->c = g->d = NULL; if (e == NULL) return g;
@   for (h = e; h->c != NULL; h = h->c);
@   h->c = g; g->d = h;
@   return e;
@ }
J Egy rendezetlen, két irányban láncolt listát.
R Egy rendezett, két irányban láncolt listát.
R Egy bináris fát.
X -----------------------------------------------------------------------------
K Ekvivalens-e egymással a p->m és a (*p).m jelölés?
J Igen.
R Nem.
X -----------------------------------------------------------------------------
K Helyes-e az alábbi típusdefiníció?
@ struct node {
@         struct node* left;
@         struct node* right;
@ };
J Igen.
R Nem, mert a definíció önhivatkozó (rekurzív).
R Nem, mert ebben a bináris fát megvalósító adatszerkezetben nincs a csomópont
@ értékét tároló tag.
X -----------------------------------------------------------------------------
K Mit csinál az alábbi függvény?
@ typedef struct bf { struct bf * b; struct bf * j; int a; } bifa;
@ int f(bifa*x){
@    if(!x)
@      return 0;
@    else 
@      return f(x->j)+f(x->b)+1;
@ }
R Megszámolja egy bináris fa leveleit.
J Megszámolja egy bináris fa csúcspontjait.
R Megméri egy bináris fa mélységét.
X -----------------------------------------------------------------------------
K Mit csinál az alábbi függvény?
@ typedef struct bf { struct bf * b; struct bf * j; int a; } bifa;
@ int f(bifa*x){
@    if(!x)
@       return 0; 
@    return f(x->j)+f(x->b)+(!x->b && !x->j?1:0);
@ }
J Megszámolja egy bináris fa leveleit.
R Megszámolja egy bináris fa csúcspontjait.
R Megméri egy bináris fa mélységét.
X -----------------------------------------------------------------------------
K Láncolt lista esetén mit nevezünk strázsának?
J Azt az érvényes értéket nem tartalmazó elemet, amellyel a lista elejét, vagy
@ végét jelöltük meg.
R Minden olyan listaelemet, amely érvényes értéket tartalmaz.
R Minden esetben a lista első elemét.
X -----------------------------------------------------------------------------
K Melyik tárolódik a heap területen?
J dinamikusan allokált memória
R globális változók
R lokális változók
X -----------------------------------------------------------------------------
K Mit jelent ha valaminek a típusa void* ?
J Ez egy általános mutató, amelyet használat előtt a megfelelő típusúra kell
@ konvertálni.
R Ez egy void típusú objektumra hivatkozó mutató.
R Ez egy olyan objektumra hivatkozó mutató, amely nem foglal memóriát.
X -----------------------------------------------------------------------------
K Melyik függvény (komponens) feladata a free() meghívása?
R Amelyik a malloc()-ot hívta.
R Senkié.
J Mindegy, csak valamelyik hívja meg.
X -----------------------------------------------------------------------------
F30 Mit ír ki az alábbi program?
@ #include <stdio.h>
@ typedef struct a {unsigned val; struct a *next;} list;
@ list *put(list *head; unsigned a) {
@    list *n = (list *)(malloc(sizeof(list)));

@    n->val = a; n->next = head;
@    return n;
@ }
@ unsigned get(list *head) {return head->val;}
@ void main(void) {
@    list *head = NULL;
@    head = put(head, %u1); head = put(head, %u2); head = put(head, %u3);
@    printf("%u", get(head));
@ }
M Mindig a lista legelején lévő elemet írja ki, az pedig a legutoljára betett
@ elem.
X -----------------------------------------------------------------------------
K Melyik utasítás helyes?
J char* c=(char*)calloc(50,sizeof(char));
R char* c=(char*)calloc(50*sizeof(char));
R char* c=(char*)realloc(50*sizeof(char));
X -----------------------------------------------------------------------------
K Az alábbi kód helyesen járja-e be a láncolt listát a megadott elemtől 
@ kezdődően? Az elem struktúra már definiálva van és tartalmaz egy mutatót
@ a következő elemre.
@ void Bejar( struct elem ** start ){
@	struct elem** iterator = start;
@	while( *iterator) iterator = &(*iterator)->kovetkezo;
@ }
J Igen helyesen járja be.
R Nem jó, nem is fordul a kód.
R Nem, mert nem járja be a listát.
X -----------------------------------------------------------------------------
K Mit csinál az alábbi függvény?
@ typedef struct le { struct le * next; int a; } lista;
@ int f(lista *x){ if(!x) return 0; return a+f(x->next);}
R Megszámolja egy láncolt lista elemeit.
J Összeszámolja egy láncolt listában tárolt elemek összegét.
R Meghatározza egy láncolt listában tárolt elemek maximumát.
X -----------------------------------------------------------------------------
K Mit csinál az alábbi függvény?
@ typedef struct bf { struct bf * b; struct bf * j; int a; } bifa;
@ int f(bifa *x){
@    if(!x)
@      return 0;
@    return x->a+f(x->j)+f(x->b);
@ }
J Összeadja egy bináris fa csúcsaiban tárolt értékeit.
R Megszámolja egy bináris fa csúcspontjait.
R Megméri egy bináris fa mélységét.
X -----------------------------------------------------------------------------
K Milyen adatszerkezet felépítésére alkalmas a következő struktúra?
@ struct elem {struct elem * egy; struct elem * ketto; int ertek; };
R Bináris fa
R Kétszeresen láncolt lista
J Mindkettő
X -----------------------------------------------------------------------------
F54 Mi lesz a p string tartalma a következő programrészlet végén?
@     char t[] = "$s1", *p = t + 1;
@     int i = 2, *q = &i;
@     p += *q;
X -----------------------------------------------------------------------------
F55 Mit ír ki a következő programrészlet?
@    int i = $u1, j = $u2, *p = &i, *q = &i;
@    (*q)++; q = &j; *q += *p;
@    printf("%d", *q);
X -----------------------------------------------------------------------------
K Szintaktikailag típushelyes-e az alábbi utasítás?
@ **p = *q;
J Igen, amennyiben **p és *q típusa megegyezik.
R Igen, amennyiben p egy egész típusú mutató.
R Nem, csak abban az esetben működne, ha *p=*q vagy p=q lenne az értékadásban.
X -----------------------------------------------------------------------------
K Mivel tér vissza az alábbi függvény?
@
@ struct Node { struct Node *a; struct Node *b; };
@ int f(struct Node *n) {  return f(n->a) + f(n->b); }
R A paraméterként kapont bináris fa csúcspontjainak számával.
R A paraméterként kapott bináris fa leveleinek számával.
J Hibával elszáll a program.
M Semmi sem állítja le a rekurziót, pedig a fában előbb-utóbb elérjük a
@ leveleket.
X -----------------------------------------------------------------------------
K Melyik sor okozza a futás idejű hibát?
@ 1. char *p;
@ 2. *p = (char *) malloc(20);    /* lefoglalunk 20 byte memóriát */
@ 3. *p = 'x';
J 2. sor hibás, nem kell * a p elé
R 2. sor hibás, & kell a p elé
R 3. sor helyesen: p[0]='x';
X -----------------------------------------------------------------------------
K Egy fésűs láncolt listának minden eleme azonos típusú?
J Nem igaz, a "fejlista" elemei mások.
R Nem igaz, minden fogban különböző típusú elmek lehetnek.
R Igaz.
X -----------------------------------------------------------------------------
K Hogyan állapítható meg a sort függvényből, hogy az array paraméter dinamikus?
@ void sort(int *array, int size) {
@   ...
J Sehogy.
R sizeof operátorral.
R cast operátorral int [] típusra.
X -----------------------------------------------------------------------------
K Mit jelent az int **i deklaráció?
R Ez egy int típusú változó, mert a két * operátor "kiejti" egymást
R Ez egy hibás deklaráció, két * operátor nem szerepelhet egymás után
J Ez egy int típusú mutatóra mutató mutató deklarációja
X -----------------------------------------------------------------------------
F67 Mit ír ki az alábbi program?
@ #include<stdio.h>
@ #include<stdlib.h>
@ int main(){
@    struct lelem{ int a; struct lelem* kov;} *kezdo=NULL, *uj;
@    int tomb[4]={ $u1, $u2, $u3, $u4};
@    int i;
@    for(i=0;i<3;i++){
@      uj = (struct lelem*)malloc(sizeof(struct lelem));
@      uj->a = tomb[i];
@      uj->kov = kezdo;
@      kezdo = uj;
@    }
@    for(uj=kezdo;uj;uj=uj->kov)printf("%d, ", uj->a);
@    for(uj=kezdo;uj;uj=kezdo){kezdo=uj->kov;free(uj);}
@ }
M A számokat mindig a lista elejére szúrja, ezért a fordított sorrendet.
X -----------------------------------------------------------------------------
K Hivatkozhatunk-e a p2 pointer által mutatott adatra a következő
@ kódrészlet után?
@ int *p1,*p2;
@ p1=(int *)malloc(5*sizeof(int)); ...
@ p2=p1+2; ...
@ p1=(int *)realloc(p1,10*sizeof(int));
J Nem, mert egy olyan dinamikus adatterületre mutat, amelyet
@ a realloc felszabadíthatott, és az arra való hivatkozás elszállást okozhat
R Igen, legfeljebb nullát kapunk eredményül
R Igen, mert a dinamikus tömb mérete legalább 5, mi pedig a 2. elemre
@ hivatkozunk
X -----------------------------------------------------------------------------
K Adott az alábbi struktúrákból felépülő bináris fa:
@ struct fa{ int kulcs; double ertek; struct fa *bal, *jobb; };
@ A fa egy érvényes csomópontjára mutató 'struct fa *p' pointeren végrehajtott
@ p++; utasítás hova állítja a pointert?
R A bal oldali ágon levő csomópontra.
R A jobb oldali ágon levő csomópontra.
J Oda, ami az adott struktúra után következik a memóriában; potenciálisan egy
@ érvénytelen, vagy nem 'struct fa'-t tartalmazó memóriaterületre.
X -----------------------------------------------------------------------------
K Mit mondhatunk a következő kódrészletről?
@   char s1[]="alma";  char s2[10];  while( *s2++ = *s1++) ;
R Az s1 sztringet átmásolja az s2 sztringbe.
J Az s1 és az s2 nem jobbérték, ezért a kód szintaktikailag hibás.
R A sztring első betűjének az értékét növeli eggyel, és a ciklusnak
@ akkor lesz vége, ha a 8 bites érték túlcsordul.
M s1 és s2 nem pointer, hanem tömb.
X -----------------------------------------------------------------------------
K Mit mondhatunk a következő kódrészletről?
@        double (*m)[10];
@        int i, j;
@        m = ( double(*)[10] ) malloc( 10 * sizeof( *m ) );
@        for(i=0; i<10; i++ )for( j=0; j<10; j++) m[i][j] = 5;
R Az m változó definíciója szintaktikailag hibás.
R Az m változó egy 10 elemű vektorra mutató pointer, ezért az m[i][j]
@ kifejezés hibás.
J Az m egy olyan pointer, amely elemei 10 elemű lebegőpontos értékeket tartal-
@ mazó vektorok, tehát a kódrészlet egy 10X10-es mátrixot foglal le a heap-en.

X *****************************************************************************
C Fájlkezelés
X *****************************************************************************

X -----------------------------------------------------------------------------
F11 Mit ír ki az alábbi program, ha az abcd.efg fájl tartalma a következő
@ szöveg?: $s1P$s2
@
@ #include <stdio.h>
@ int main(){
@    FILE * fp=fopen("abcd.efg","rb");
@    char c;

@    while(fread(&c,1,1,fp)==1)if(c>'M'&&c<'Z')putchar('2');
@    fclose(fp); return 0;
@ }
X -----------------------------------------------------------------------------
K A kívánt módon beolvassa-e az alábbi kódrészlet a c tömbbe a megadott
@ állomány első tíz karakterét?
@ char c[10];
@ FILE* f = fopen("filename.ext", "rb");
@ fread(c, 1, 10, f);
@ fclose(f);
J Igen, de a c tömb tartalmának kiírásakor ügyelni kell arra, hogy a beolvasott
@ füzér végén nincs lezáró null-karakter.
R Nem, mert az állományt binárisan nyitjuk meg, de abból szöveget olvasunk ki.
R Nem, mert a beolvasáskor túlcsordulás lép fel.
X -----------------------------------------------------------------------------
K Mi történik a következő programmal, ha nem létezik a "szoveg.txt" fájl?
@ FILE *fp;  fp = fopen("szoveg.txt", "r");
R Megáll a program futása.
R Létrehoz egy üres fájlt a megadott névvel.
J fp értéke NULL lesz.
M A NULL, sehova sem mutató pointerrel jelzi a művelet sikertelenségét.
X -----------------------------------------------------------------------------
K Mit ír ki a program, ha az a.txt tartalma 5db karakter?
@ main(){
@   FILE * tf;  int a = 0;
@   tf = fopen("a.txt", "rt"); while(!feof(tf)) { fgetc(tf); a++; }
@   fclose (tf); printf("%d\n", a);
@ }
J 6
R 5
R 0
M feof akkor teljesül, ha már történt egy sikertelen olvasás.
X -----------------------------------------------------------------------------
K Mi a típusa a stdin, stdout, és stderr -nek?
J FILE*
R FILE
R void*
X -----------------------------------------------------------------------------
K Melyik sor hibás?
@ #include <stdio.h>
@ void main(){
@ /*1*/	printf("stdin:  %d\n",fileno(stdin));
@ /*2*/	printf("stdout: %d\n",fileno(stdout));
@ /*3*/	printf("stderr: %d\n",fileno(stderr));
@ }
R 1 és 2
R 2 és 3
J egyik sem
M A fileno függvény a fájl azonosítóját adja, in/out/err általában 0/1/2
X -----------------------------------------------------------------------------
K Mit ír ki az alábbi program, ha az a.txt fájl tartalma a következő
@ szöveg?: 1 2.0 2 8.0
@
@ main(){
@   FILE *f=fopen("a.txt","r");
@   int b=1, d=0; double c=8.0;
@   while(fscanf(f, "%d %lf", &b, &c) > 0&& ++d) 
@      printf("%d %.1f ",b, c);
@   fclose(f); 
@   printf("%i\n",d);
@ }
J 1 2.0 2 8.0 2
R 1 2.0 2 8.0 3
R 1
X -----------------------------------------------------------------------------
K Helyes-e az alábbi kódrészlet?
@ fopen("c:\user\szover.txt");
R Igen.
J Nem, mert a backslash-t meg kell duplázni.
X -----------------------------------------------------------------------------
K Mi történik a következő programmal, ha nem létezik a "szoveg.txt" fájl?
@ FILE *fp;  fp=fopen("szoveg.txt", "w");
R Megáll a program futása.
J Létrehoz egy üres fájlt a megadott névvel.
R fp értéke NULL lesz.
X -----------------------------------------------------------------------------
K Mit ír ki a következő programrészlet? (feltehetjük, hogy input.txt legalább
@ 5 karaktert tartalmaz)
@    char c[10];
@    FILE* f = fopen("input.txt", "r");
@    fread(c, 1, 5, f);
@    fclose(f);
@    printf("%d", strlen(c));
R 10
R 5
J Nem lehet megmondani.
X -----------------------------------------------------------------------------
K Mi az fread függvény visszatérési értéke?
J A sikeresen beolvasott elemek darabszáma.
R A beolvasott byte-ok száma.
R Egy void * pointer, amely a beolvasott byte-okat tartalmazó tömb első
@ elemére mutat.
X -----------------------------------------------------------------------------
K Mi történik a következő programmal, ha nem létezik a "szoveg.txt" fájl?
@ FILE * fp;  fp=fopen("szoveg.txt", "r");
R Megáll a program futása.
J fp értéke NULL lesz.
R Létrejön a "szoveg.txt" nevű fájl.
X -----------------------------------------------------------------------------

K Ha az out.txt fájlban az "xxx" szöveg található kezdetben, akkor mi
@ található benne az alábbi kódrészlet futtatása után?
@
@ FILE* fp = fopen("out.txt", "at"); fprintf(fp, "yyy"); fclose(fp);
R "xxx", és a kódrészlet hibát ad, mert a fájl már létezik
R "yyy"
J "xxxyyy"
M Az "a" mód esetén a fájlhoz hozzátoldunk.
X -----------------------------------------------------------------------------
K Ha az out.txt fájlban az "xxx" szöveg található kezdetben, akkor mi
@ található benne az alábbi kódrészlet futtatása után?
@
@ FILE* fp = fopen("out.txt", "wt"); fprintf(fp, "yyy"); fclose(fp);
R "xxx", és a kódrészlet hibát ad, mert a fájl már létezik
J "yyy"
R "xxxyyy"
M A "w" mód esetén a fájl automatikusan felülíródik.
X -----------------------------------------------------------------------------
K Mi történik, ha nem létezik a szoveg.txt fájl?
@ FILE *fp;  fp = fopen("C:\\szoveg.txt", "a");
R Megáll a program futása.
J Létrejön egy üres fájlt a megadott névvel.
R fp értéke NULL lesz.
X -----------------------------------------------------------------------------
K Melyik állítás HAMIS?
R FILE * fopen("valami.jpg","r+b"); megnyitás esetén valami.jpg létező fájl
@ kell legyen, a fájlt egyaránt írhatjuk és olvashatjuk.
R FILE * fopen("valami.jpg","w+b"); megnyitás esetén valami.jpg nemlétező fájl
@ is lehet, a fájlt egyaránt írhatjuk és olvashatjuk.
J FILE * fopen("valami.jpg","a+b"); megnyitás esetén valami.jpg létező fájl
@ kell legyen, a fájlt egyaránt írhatjuk és olvashatjuk.
X -----------------------------------------------------------------------------
K Egy fopen("myfile", "a+")) hívással megnyitott myfile szövegfájlba lehet-e
@ írni az fwrite függvénnyel?
J Igen
R Nem, csak bináris fájlok írhatók az fwrite-tal
R Mivel csak olvasásra nyitottuk meg, ezért nem írható
X -----------------------------------------------------------------------------
K Szöveges fájlt nem lehet bináris üzemmódban megnyitni.
R Igaz.
R Nem igaz, az operációs rendszer ilyenkor automatikusan átvált szöveges módra.
J Nem igaz, hisz a szöveges fájl is bitekből áll.
X -----------------------------------------------------------------------------
K Hogyan használható fel az fprintf a szabványos kimenetre való írásra?
R Sehogy, csak a printf használható erre, az fprintf csak fájlba írhat.
J Az stdout globális változóval.
X -----------------------------------------------------------------------------
K Mire jó az alábbi függvény?
@ unsigned func1 (char *name){
@   FILE *stream; unsigned s;
@   stream=fopen(name,"r"); fseek(stream, 0L, SEEK_END); 
@   s=ftell(stream); fclose(stream); return s;
@ }
R Megadja a fájl utolsó módosításának dátumát
R Megadja a fájlban lévő az utolsó egész számot
J Megadja a fájl méretét
X -----------------------------------------------------------------------------
F68 Mit ír ki az alábbi program, ha az x fájl tartalma a következő 3 karakter:
@ 123
@ #include <stdio.h>
@ int main(void){
@    FILE *f; int c;
@    f=fopen("x","rb");
@    while (!feof(f)){
@       fscanf(f,"%c",&c);
@       printf("%c",c);
@    }
@    return 0;
@}
M 1233 mert feof csak akkor IGAZ, amikor már történt egy sikertelen fscanf,
@ amely nem változtatta meg a c változó utolsó értékét (3)
X -----------------------------------------------------------------------------
K Mennyi lesz 'x' értéke az alábbi kódrészlet lefutása után, ha az "in.txt" 
@ állomány csupán a "Sphaerospira rockhamptonensis" szöveget tartalmazza 
@ (idézőjelek nélkül, újsorjel nélkül)?
@   FILE *f; char t[100]; int x;
@   f = fopen("in.txt","r");
@   x = fread(t, 1, 100, f);
R -1
R 100
J 29
X -----------------------------------------------------------------------------