**1. Feladat**: Olvasson be változó számú Neptun kódokat és érdemjegyeket egy struktúrába és írassa ki az eredményt.
#include // printf() és scanf() miatt kell
#include // malloc() miatt kell
struct Hallgato
{
char neptun_kod[10];
int jegy;
};
int main()
{
struct Hallgato *ptr;
int i, db;
printf("Hany hallgato van? ");
scanf("%d", &db);
ptr = (struct Hallgato*) malloc (db * sizeof(struct Hallgato));
for(i = 0; i < db; ++i)
{
printf("Kerem a Neptun kodot es a jegyet:\n");
scanf("%s %d", ptr[i].neptun_kod, &ptr[i].jegy);
}
printf("Osszesen:\n");
for(i = 0; i < db ; ++i)
{
printf("%s\t%d\n", ptr[i].neptun_kod, ptr[i].jegy);
}
}
**2. Feladat**: Láncolt lista: készítsünk egy //int szam//-ot tartalmazó struktúrát, ami tartalmaz egy mutatót egy önmagával megegyező típusra //next// néven.
#include
struct Elem
{
int szam;
struct Elem *next;
};
int main()
{
}
**3. Feladat**: Láncolt lista: az előzőből hozzunk éltre két darabot dinamikusan, az első a másodikra mutasson.
#include
#include
struct Elem
{
int szam;
struct Elem *next;
};
int main()
{
struct Elem* e1 = (struct Elem*) malloc(sizeof(struct Elem));
struct Elem* e2 = (struct Elem*) malloc(sizeof(struct Elem));
// osszekotes első variacio
e1->next = &e2[0];
// osszekotes 2. variacio
e1[0].next = e2;
}
**4. Feladat**: Láncolt lista: Készítsünk egy függvényt, ami kiírja a lista összes elemét. Majd kérjünk be a felhasználótól tetszőleges számú dinamikusan létrehozott listaelemet.
#include
#include
typedef struct Elem // azért lett typedef, hogy kényelmes függvényparaméter lehessen
{
int szam;
struct Elem *next; // a 'struct Elem' nem mas mint onmaga
} Elem;
void printList(Elem * head)
{
Elem * current = head;
while (current != NULL)
{
printf("%d\n", current->szam);
current = current->next;
}
}
int main()
{
int db;
printf("Hany elemet ad meg?");
scanf("%d", &db);
Elem *last = NULL;
Elem *first = NULL;
for(int i=0; i < db; i++)
{
Elem* e = (Elem*) malloc(sizeof(Elem));
e->next = NULL; // probaljuk ki úgy is, hogy ezt a sort kitoroljuk. Magyarazzuk meg miert tortenik?
if(last != NULL) // ha nem az elsőt töltjük fel
{
last->next = e;
}
else // ha az elsőt töltjük fel, az elsőt eltároljuk, mert e nélkül elveszne az első eleme a listának
{
first = e;
}
printf("Kerem az %d.-t:", i);
scanf("%d", &e->szam);
last = e; // osszekotjuk a ket strukturat
}
printList(first);
}
**5. Feladat**: Értsük meg jobban a typedef használatát a _types.h kódrészlete alapján:
/* sys/x86/include/_types.h in FreeBSD */
/* this is machine dependent */
#ifdef __LP64__
typedef unsigned long __uint64_t;
#else
__extension__
typedef unsigned long long __uint64_t;
#endif
...
...
typedef __uint64_t __size_t;
A fenti kódpélda az **//unsigned long long//** ot rövidíti **//__size_t//**-nek (64 bites rendszereken). A következő kódrészlet 3 féle struktúradefiníciót alkalmaz:
#include
#include
/* uj tipust hozunk létre Item neven.
A struct elem_t helyett Item-et irhatunk kesobb
*/
typedef struct elem_t
{
char *text;
int count;
struct elem_t *next; /* itt meg nem lehet roviditeni */
} Item;
/* normal struktura definicio */
struct item
{
char *text;
int count;
struct item *next;
};
/*
* ez valojaban egy nevtelen struktura
*/
struct
{
int i;
char c;
} nevtelen;
int main(void)
{
// mutato a "struct item"-re
struct item *pi = (struct item *)malloc(sizeof(struct item));;
pi->count = 10;
// Roviditett hasznalata a "struct item_t"-nek
Item *iI = (Item *)malloc(sizeof(Item));
iI->count = 5;
iI->next = iI; // onmagara mutat (csak a pelda kedveert)
// nevtelen structura
nevtelen.i = 9;
nevtelen.c = 'x';
}
**6. Feladat**: A 4. példához készítsünk egy **//Elem* pop()//** függvényt, ami az első elemet eltávolítja a listából
Elem* pop(Elem *first)
{
Elem *ret = first->next;
free(first);
return ret;
}
**7. Feladat**: A 4. példához készítsünk egy **//void sort(Elem*)//**, ami sorbarendezi növekvő sorrendbe a lista elemeit, az értékek módosításával.
void sort(Elem *first)
{
Elem *e1, *e2;
e1 = first;
while(e1->next != NULL)
{
e2 = e1->next;
while(e2 != NULL)
{
if(e2->szam < e1->szam)
{
int tmp = e2->szam;
e2->szam = e1->szam;
e1->szam = tmp;
}
e2 = e2->next;
}
e1 = e1->next;
}
}
===== Ellenőrző kérdések =====
** Mi igaz a struktúrákra az alábbiak közül? **
A) Egy struktúrában tárolt értékek típusa mindig azonos kell legyen.
B) A struktúrákat nem lehet függvényparaméterként átadni.
C) Egy struktúra különböző típusú adatokat tárolhat.
D) Egy struktúrában csak primitív típusokat lehet használni.
Megoldás: C
----
** Melyik állítás hamis a struktúrák kapcsán? **
A) A struktúra minden eleme egy külön memóriahelyen tárolódik.
B) Egy struktúra eleme lehet egy másik struktúra.
C) Egy struktúra tartalmazhat saját maga típusát is közvetlenül.
D) Struktúra használható tömbök elemeként is.
Megoldás: C --> saját magát csak pointerként tartalmazhatja, közvetlenül nem.
----
**Hogyan kell helyesen deklarálni egy struktúrát, ami két egész számot tárol?**
A) struct Point {int x; int y;};
B) struct int {x, y};
C) structure point {int x; int y;};
Megoldás: A
----
**Hogyan lehet inicializálni a Point struktúra típusú változót helyesen?**
struct Point { int x; int y; };
A) struct point p = [10, 20];
B) struct point p = {10; 20};
C) struct Point p = {10, 20};
D) struct p = {10, 20};
Megoldás: C
----
** Hogyan érhető el helyesen a struktúra adattagja pointeren keresztül? **
struct Car { int year; };
struct Car mycar = {2020};
struct Car *ptr = &mycar;
A) *ptr.year
B) ptr->year
C) ptr.year
D) ptr.(*year)
megoldás: C
----
**Mi a hiba az alábbi kódban?**
struct Person {
char name[20];
int age;
};
struct Person p;
p.name = "Alice";
p.age = 30;
A) p.age rosszul inicializált.
B) A struktúra deklaráció helytelen.
C) Tömbhöz nem rendelhető érték közvetlenül (name).
D) Nincs hiba.
Megoldás: C, mivel sztringet nem lehet tömbhöz így hozzárendelni, helyesen pl.: ''strcpy(p.name, "Alice");'' lenne
----
** Hogyan adjuk át egy struktúra pointerét paraméterként függvénynek? **
A) void f(struct Person &p);
B) void f(struct Person p*);
C) void f(struct Person *p);
D) void f(Person *p);
Megoldás: C
----