1. kártya
#include <stdio.h>
int
main (void)
{
int h = 0;
int n = 0x01; //*n változó deklarálása egy hexadecimális számmal (0000....01 így néz ki kettes számrendszerben)*//
do
{
++h;
printf("[%d %u]\n", h,n); //*kiírja az aktuális helyiértéken az adott hatványt! %u előjel nélküli a negatív számok kizárása miatt*//
}
while (n <<= 1); //*Helyiérték eltolás (egyel balra) ez egy feltétele a ciklusnak 32 bit után válik hamissá*//
printf("A szóhossz ezen a gépen: %d bites\n", h);
return 0;
}
Mit csinál a program?
Előállítja a 2 hatványait!
Mit ír ki a kockás zárójelek között?
%d-> előjeles egész típusú kíírás
%u-> előjel nélküli egészkíírás(mert az utolsó jegynél túlcsordulás miatt negatívat kapnánk)
Mit írna ki printf ("[%d %d]\n", h, n); esetén?
Mindkettő előjeles egész típusú lenne ezért az utolsó jegynél negatív számot kapnánk!
int
main (void)
{
for(;;) //* Nincs szabályozva a for ciklus ezért végtelen ciklus keletkezik!*//
;
}
/*
Mit csinál ez a program?
Ez egy végtelen ciklus.*/
2. kártya
#include <stdio.h>
int
main (void)
{
inc c;
while ((c = getchar ()) != EOF) //* Végjelig olvasbe a billentyűzetről karaktereket mindaddig amíg nem viszünk EOF(End Of File) jelet!*//
putchar (c); //* Kiírja a bevitt karaktert!*//
return 0;
}
Mit csinál ez a program?
A bevitt karaktert újra kiírja végjelig!
#include <stdio.h>
#include <stdlib.h>
int
main (void)
{
int i, r;
for (i = 0; i < 10; ++i)
{
r = 1 + (int) (10.0 * rand () / (RAND_MAX + 1.0));
printf ("%d ", r);
}
printf ("\n");
return 0;
}
Mit csinál ez a program?
Random (véletlenszerüen) generál 10 számot 1-10-ig egészeket!
Mit csinál ez a program, ha többször futtatod egymás után?
A számok nem fognak változni mert nincs meghívva a time.h include és a srand(time( NULL ))függvény ami minden futtatásnál biztosítaná a véletlen számok előállítását!
3. kártya
#include <stdio.h>
#include <stdlib.h>
int main (void){
int i =0; // beolvasott számok darabszáma
double r, s =0.0; // r: számok beolvasása ebbe a változóba történik
// s: beolvasott számokat ehez adjuk hozzá
while(scanf("%lf", &r) > 0) // számok beolvasása az 'r' változóba amíg nem nyomunk Ctrl+D-t
{
++i; // i növelése 1-el, beolvasott számok darabszáma
s +=r; // s-hez hozzadjuk a beolvasott számot ( s = s + r )
}
printf("%lf\n", s / i); // kiírjuk az átlagot ( számok összege osztva a bolvaott darabszámmal )
return 0;
}
/* A program számot olvas be (törtet is a double típus miatt) najd a beolvasott számot hozzáadja az 's' nevű változóhoz.
( összegzi a beolvasott számokat ) Minden beolvasott számkor növli az 'i' változó értékét mivel a végén az átlagszámításhoz
szükségünk lesz hány számot olvastunk be. Ezt a beolvasást addig folytatja amíg Ctlr+D-t nyomunk. Ezután kiírjuk a beolvasott számok átlagát*/
4. kártya
// rszamok.c
#include <stdio.h>
#include <stdlib.h>
int
main (void)
{
int i, r;
for (i = 0; i < 1000; ++i)
{
r = 1 + (int) (10.0 * rand () / (RAND_MAX + 1.0));
printf ("%d ", r);
}
printf ("\n");
return 0;
}
// atlag.c
#include <stdio.h>
#include <stdlib.h>
int main (void){
int i =0;
double r, s =0.0;
while(scanf("%lf", &r) > 0)
{
++i;
s +=r;
}
printf("%lf\n", s / i);
return 0;
}
/*
nbatfai@hallg:~/c$ gcc atlag.c -o atlag
nbatfai@hallg:~/c$ gcc rszamok.c -o rszamok
nbatfai@hallg:~/c$ ./rszamok|./atlag
Mit ír ki és mit jelent az utolsó parancs?
A radomba generált számok ( rszamik.c ) nek az átlagának a kiszámítása ( beolvassa(atlag.c) az értékeket amit a másik program generál ).
Mivel a randomszám generátor ugyan azokat az értékeket generálja a végeredmény is ugyan az lesz mindig.
Képernyőre ennyit ír: 5.574000
*/
5. kártya
Mi a különbség a két ciklus között?
for(i=0;i<3;++i)
printf("%d",i);
for(i=0;i<3;i++)
printf("%d",i);
//Semmi, mivel az 'i' léptetése mindig a ciklusmag lefutása után történik.
if(signal(SIGINT, jelkezelo) == SIG_IGN)
signal(SIGINT, SIG_IGN)
if(signal(SIGINT, SIG_IGN) != SIG_IGN)
signal(SIGINT, jelkezelo);
//Semmi különbség. Ctlr+C gombra lefut a 'jelkezelo' függvény. Két különböző logika beállításmód végülis.
6. kártya
int a; //'a' egész típusú változó
int *b; //'b' egy egészre mutató mutató
int c[5]; //'c' egészeket tartalmazó tömb melynek 5 eleme van
int *d[5]; //'d' egy mutató tömb, 5 darab egészre mutató mutató tartalmaz
int e[3][3]; //'e' két dimenziós tömb ( 3 sor, 3 oszlop )
int *f (); //'f' függvény egészre mutató mutatót ad vissza
int (*g)(); //'g' egy egészet visszaadó függvényre mutató mutató
char a; //'a' karakter típusú változó
char *b; //'b' egy karakterre mutató mutató
char c[5]; //'c' karaktereket tartalmazó tömb melynek 5 eleme van
char *d[5]; //'d' egy mutató tömb, 5 darab karakterre mutató mutató tartalmaz
char e[3][3]; //'e' két dimenziós tömb ( 3 sor, 3 oszlop )
char *f (); //'f' függvény karakterre mutató mutatót ad vissza
char (*g)(); //'g' egy karaktert visszaadó függvényre mutató mutató
void (*g)(int); //'g' egy olyan függvényre mutató mutató, ami int típusú értéket kap és nem ad vissza értéket
void (*g)(); //'g' egy olyan függvényre mutató mutató, ami nem kap és nem ad vissza értéket
void* (*g)(void *); //'g' egy void*-ot váró, void *-ot visszaadó függvényre mutató mutató
7. kártya
#include <stdio.h>
#define MERET 5
char buffer[MERET];
char *string_masolo_man_p1_alapjan(char *dest, const char *src, int n)
{
int i;
for(i=0; i < n && src[i]!='\0'; i++)
dest[i] = src[i];
for(;i<n;i++)
dest[i]='\0';
return dest;
}
int main(){
string_masolo_man_p1_alapjan(buffer,"aaaaaaaaaaaaaaaaaaaaaaaaaa",MERET);
printf("%s\n",buffer);
string_masolo_man_p1_alapjan(buffer,"bbbbbbbbbbbbbbbbbbbbbbbbbb",MERET-1);
printf("%s\n",buffer);
return 0;
}
/* Program első fügvénye a buffer karaktertömbbe másol 5 darab 'a' betűt majd kiírja a képernyőre. Második függvény szintén a buffer tömbe másol 4 db b karaktert majd kiírja.
Kimenet:
aaaaa
bbbba
*/
