Differences

This shows you the differences between two versions of the page.

--- tanszek:oktatas:muszaki_informatika:strukturak_c-ben [2024/02/13 19:40] – létrehozva knehez
+++ tanszek:oktatas:muszaki_informatika:strukturak_c-ben [2025/03/13 22:47] (current) – [Ellenőrző kérdések] knehez
@@ Line 1: / Line 1: @@
-==== Mátrixok használata ====
+**1. Feladat**: Olvasson be változó számú Neptun kódokat és érdemjegyeket egy struktúrába és írassa ki az eredményt.
-**1. feladat:** Adjunk össze két 3x3-as egész számokat tároló mátrix-ot és tároljunk le egy harmadikban az eredményt. Használjunk függvényt a mátrix elemeinek bekéréséhez.
 <sxh c>
-#include <stdio.h>
+#include<stdio.h>  // printf() és scanf() miatt kell
+#include<stdlib.h> // malloc() miatt kell
-#define SIZE 3 // a matrix-ok merete
-void readMatrix(int m[][SIZE])
+struct Hallgato
 {
-    for(int sor = 0; sor < SIZE; sor++)
+    char neptun_kod[10];
-    {
+    int jegy;
-        for(int oszlop = 0; oszlop < SIZE; oszlop++)
+};
-        {
-            scanf("%d", &m[sor][oszlop]);
-        }
-    }
-}
 int main()
 {
-    int A[SIZE][SIZE]; // Matrix 1
+    struct Hallgato *ptr;
-    int B[SIZE][SIZE]; // Matrix 2
+    int i, db;
-    int C[SIZE][SIZE]; // eredmeny Matrix
+    printf("Hany hallgato van? ");
+    scanf("%d", &db);
-    printf("Kerem az elso matrix elemeit: \n");
-    readMatrix(A);
+    ptr = (struct Hallgato*) malloc (db * sizeof(struct Hallgato));
-    printf("Kerem az masodik matrix elemeit: \n");
-    readMatrix(B);
+    for(i = 0; i < db; ++i)
-    for(int sor = 0; sor < SIZE; sor++)
     {
-        for(int oszlop = 0; oszlop < SIZE; oszlop++)
+        printf("Kerem a Neptun kodot es a jegyet:\n");
-        {
+        scanf("%s %d", ptr[i].neptun_kod, &ptr[i].jegy);
-            C[sor][oszlop] = A[sor][oszlop] + B[sor][oszlop];
-        }
     }
+    printf("Osszesen:\n");
-    printf("\nMatrixok osszege: A+B = \n");
+    for(i = 0; i < db ; ++i)
-    for(int sor = 0; sor < SIZE; sor++)
     {
-        for(int oszlop = 0; oszlop < SIZE; oszlop++)
+        printf("%s\t%d\n", ptr[i].neptun_kod, ptr[i].jegy);
-        {
-            printf("%d ", C[sor][oszlop]);
-        }
-        printf("\n");  // soronkent uj sor
     }
 }
 </sxh>
-**2. feladat:** Az első feladatban a <sxh c>readMatrix()</sxh> függvényt cseréljük le: <sxh c>void readMatrix(int ** m)</sxh> -ra és próbáljuk meg mi történik és magyarázzuk meg miért?
+**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.
-**3. feladat:** Az első feladatban megadott feladatot oldjuk meg pointerekkel is.
 <sxh c>
 #include <stdio.h>
+struct Elem
-#define SIZE 3 // a matrix-ok merete
-void readMatrix(int *m)
 {
-    for(int i = 0; i < SIZE * SIZE; i++)
+    int szam;
-    {
+    struct Elem *next;
-        scanf("%d", (m + i));
+};
-    }
-}
 int main()
 {
-    int A[SIZE][SIZE]; // Matrix 1
-    int B[SIZE][SIZE]; // Matrix 2
-    printf("Kerem az elso matrix elemeit: \n");
+}
-    readMatrix(&A[0][0]);
+</sxh>
-    printf("Kerem az masodik matrix elemeit: \n");
-    readMatrix(&B[0][0]);
-    int C[SIZE][SIZE]; // eredmeny Matrix
+**3. Feladat**: Láncolt lista: az előzőből hozzunk éltre két darabot dinamikusan, az első a másodikra mutasson.
-    for(int i = 0; i < SIZE * SIZE; i++)
+<sxh c>
-    {
+#include <stdio.h>
-        *(&C[0][0] + i) = *(&A[0][0] + i) + *(&B[0][0] + i);
+#include <stdlib.h>
-    }
+struct Elem
+{
+    int szam;
+    struct Elem *next;
+};
-    printf("\nMatrixok osszege: A+B = \n");
+int main()
-    for(int sor = 0; sor < SIZE; sor++)
+{
-    {
+    struct Elem* e1 = (struct Elem*) malloc(sizeof(struct Elem));
-        for(int oszlop = 0; oszlop < SIZE; oszlop++)
+    struct Elem* e2 = (struct Elem*) malloc(sizeof(struct Elem));
-        {
+    // osszekotes első variacio
-            printf("%d ", C[sor][oszlop]);
+    e1->next = &e2[0];
-        }
+    // osszekotes 2. variacio
-        printf("\n");  // soronkent uj sor
+    e1[0].next = e2;
-    }
 }
 </sxh>
-**4. feladat:** Ellenőrizzük, hogy a felhasználótól bekért 3x3-as mátrix felső háromszög típusú-e?
+**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.
 <sxh c>
 #include <stdio.h>
+#include <stdlib.h>
-#define SIZE 3 // a matrix-ok merete
+typedef struct Elem  // azért lett typedef, hogy kényelmes függvényparaméter lehessen
-void readMatrix(int m[][SIZE])
 {
-    for(int sor = 0; sor < SIZE; sor++)
+    int szam;
+    struct Elem *next;  // a 'struct Elem' nem mas mint onmaga
+} Elem;
+void printList(Elem * head)
+{
+    Elem * current = head;
+    while (current != NULL)
     {
-        for(int oszlop = 0; oszlop < SIZE; oszlop++)
+        printf("%d\n", current->szam);
-        {
+        current = current->next;
-            scanf("%d", &m[sor][oszlop]);
-        }
     }
 }
@@ Line 114: / Line 97: @@
 int main()
 {
-    int A[SIZE][SIZE];
+    int db;
+    printf("Hany elemet ad meg?");
+    scanf("%d", &db);
-    printf("Kerem a matrix elemeit: \n");
+    Elem *last = NULL;
-    readMatrix(A);
+    Elem *first = NULL;
+    for(int i=0; i < db; i++)
-    int felsoHaromszog = 1;
-    // Hogyan jovunk ra a megoldasra?
-    //
-    // 1 2 3   [0,0] [0,1] [0,2]
-    // 0 4 5 =>[1,0] [1,1] [1,2]
-    // 0 0 6   [2,0] [2,1] [2,2]
-    //
-    // Mi a közös a három 0 érték indexeiben?
-    // - az hogy a sor index erteke mindig nagyobb mint
-    // az oszlop index!!
-    //
-    for(int sor = 0; sor < SIZE; sor++)
     {
-        for(int oszlop = 0; oszlop < SIZE; oszlop++)
+        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;
-            // a foatlo alatti elemeknek 0-nak kell lenniuk
-            //
-            if(sor > oszlop && A[sor][oszlop]!=0)
-            {
-                felsoHaromszog = 0;
-            }
         }
+        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
     }
-    if(felsoHaromszog)
+    printList(first);
-    {
-        printf("felso haromszog matrix");
-    }
-    else
-    {
-        printf("nem felso haromszog");
-    }
 }
+</sxh>
+**5. Feladat**: Értsük meg jobban a typedef használatát a _types.h kódrészlete alapján:
+<sxh c>
+/* 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;
 </sxh>
-**5. feladat:** Írjon C programot, ami meghatározza, hogy egy mátrix ritka mátrix-e? Egy ritka mátrix olyan mártix aminek legalább elemeinek a fele 0.
+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:
-**6. feladat:** Írjon C programot, ami bekér a felhasználótól egy 3x3-as mátrixot és kiírja a transzponáltját.
 <sxh c>
 #include <stdio.h>
+#include <stdlib.h>
-#define SIZE 3 // a matrix-ok merete
+/* uj tipust hozunk létre Item neven.
-void readMatrix(int m[][SIZE])
+   A struct elem_t helyett Item-et irhatunk kesobb
+*/
+typedef struct elem_t
 {
-    for(int sor = 0; sor < SIZE; sor++)
+    char *text;
-    {
+    int count;
-        for(int oszlop = 0; oszlop < SIZE; oszlop++)
+    struct elem_t *next; /* itt meg nem lehet roviditeni */
-        {
+} Item;
-            scanf("%d", &m[sor][oszlop]);
-        }
-    }
-}
-int main()
+/* normal struktura definicio */
+struct item
 {
-    int A[SIZE][SIZE];
+    char *text;
-    int E[SIZE][SIZE];
+    int count;
-    printf("Kerem a matrix elemeit: \n");
+    struct item *next;
-    readMatrix(A);
+};
-    // Hogyan jovunk ra a megoldasra?
+/*
-    // Transzpontalt matrix pelda:
+* ez valojaban egy nevtelen struktura
-    //
+*/
-    // 1 2 3    1 4 7
+struct
-    // 4 5 6 => 2 5 8
+{
-    // 7 8 9    3 6 9
+    int i;
-    //
+    char c;
-    // A matrix [i][j] elemét [j][i]-re kell cserelni
+} nevtelen;
-    for(int sor = 0; sor < SIZE; sor++)
-    {
-        for(int oszlop = 0; oszlop < SIZE; oszlop++)
-        {
-            E[sor][oszlop] = A[oszlop][sor];
-        }
-    }
-    for(int sor = 0; sor < SIZE; sor++)
+int main(void)
-    {
+{
-        for(int oszlop = 0; oszlop < SIZE; oszlop++)
+    // mutato a "struct item"-re
-        {
+    struct item *pi = (struct item *)malloc(sizeof(struct item));;
-            printf("%d ", E[sor][oszlop]);
+    pi->count = 10;
-        }
-        printf("\n");
+    // 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';
 }
 </sxh>
-**7. feladat:** Írjon C programot, ami összeszoroz két mátrixot.
+**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
 <sxh c>
-#include <stdio.h>
+Elem* pop(Elem *first)
-#define MAX_SOR 3
-#define MAX_OSZLOP 3
-void readMatrix(int m[][MAX_OSZLOP])
 {
-    for(int sor = 0; sor < MAX_SOR; sor++)
+    Elem *ret = first->next;
-    {
+    free(first);
-        for(int oszlop = 0; oszlop < MAX_OSZLOP; oszlop++)
+    return ret;
-        {
-            scanf("%d", &m[sor][oszlop]);
-        }
-    }
 }
+</sxh>
+**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.
-int main()
+<sxh c>
+void sort(Elem *first)
 {
-    int A[MAX_SOR][MAX_OSZLOP];
+    Elem *e1, *e2;
-    int B[MAX_SOR][MAX_OSZLOP];
+    e1 = first;
-    int C[MAX_SOR][MAX_OSZLOP];
+    while(e1->next != NULL)
-    printf("Kerem az A matrix elemeit: \n");
-    readMatrix(A);
-    printf("Kerem a B matrix elemeit: \n");
-    readMatrix(B);
-    for (int sor = 0; sor < MAX_SOR; sor++)
     {
-        for (int oszlop = 0; oszlop < MAX_OSZLOP; oszlop++)
+        e2 = e1->next;
+        while(e2 != NULL)
         {
-            int sum = 0;
+            if(e2->szam < e1->szam)
-            for (int i = 0; i < MAX_OSZLOP; i++)
             {
-                sum += (*(*(A + sor) + i)) * (*(*(B + i) + oszlop));
+                int tmp = e2->szam;
+                e2->szam = e1->szam;
+                e1->szam = tmp;
             }
-            *(*(C + sor) + oszlop) = sum;
+            e2 = e2->next;
         }
+        e1 = e1->next;
     }
+}
+</sxh>
+===== Ellenőrző kérdések =====
+** Mi igaz a struktúrákra az alábbiak közül? **
-    for(int sor = 0; sor < MAX_SOR; sor++)
+  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.
-        for(int oszlop = 0; oszlop < MAX_OSZLOP; oszlop++)
+  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.
-            printf("%d ", C[sor][oszlop]);
-        }
+Megoldás: C
-        printf("\n");
-    }
+----
-}
+** 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?**
+<sxh c>
+struct Point { int x; int y; };
 </sxh>
-**8. feladat:** Írja át az előző példában a sum += (*(*A + sor .... -t az egyszerűbb indexes A[i][j]- alakra!
+  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? **
 <sxh c>
-sum += A[sor][i] * B[i][oszlop];
+struct Car { int year; };
+struct Car mycar = {2020};
+struct Car *ptr = &mycar;
 </sxh>
+  A) *ptr.year
+  B) ptr->year
+  C) ptr.year
+  D) ptr.(*year)
+megoldás: C
+----
+**Mi a hiba az alábbi kódban?**
+<sxh c>
+struct Person {
+    char name[20];
+    int age;
+};
+struct Person p;
+p.name = "Alice";
+p.age = 30;
+</sxh>
+  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
+----