Labor 11

C programozással kapcsolatos vizsgakérdések (16 db)

Bináris fileok

Teljesítménymérés

Programtervezés, kódszervezés

sima C kód optimalizálása CPU-ra

Vizsga kérdések

Vizsga kérdések

23. Ismertesse a veremtár működését! C nyelvű programok futása közben hol van szerepe a veremtárnak?

      //Automatikus változók kezelése 
    
        void foo(void) {
          int a = 5;           // a ‘a’ a veremben él
          char tmp[100];       // buffer a veremben,
      }                        // kilépéskor a teljes blokk “eltűnik”            
          

Vizsga kérdések

35. Ismertesse a C nyelvű forráskód fordítási és futtatási folyamatát!

Vizsga kérdések

43. Ismertesse a C nyelv alapvető típusait, tárolási méretükkel! Hol vannak ezek a méretek definiálva (típusonként eltérő)?

Vizsga kérdések

44. Ismertesse példával a pre- és posztinkrementálás közti különbséget!

        #include <stdio.h>

          int main(void) {
              int a = 5;
              int b = ++a;   /* pre-increment  */
              int c = 5;
              int d = c++;   /* post-increment */
          
              printf("a = %d, b = %d\n", a, b);
              printf("c = %d, d = %d\n", c, d);
              return 0;
          }                          
            

              //kimenet
              a = 6, b = 6
              c = 6, d = 5                               
                  

Vizsga kérdések

45. Ismertesse a C nyelv háromoperandusú operátorát!

      //egyszerű pl.
      int min = (a < b) ? a : b;               
          

      //bonyolultabb pl1.
      ((x < 0) ? x : y) = 0;   /* csak akkor érvényes, ha x és y is int változó */
      //Ha x < 0 igaz, x lesz kinullázva, különben y.
    

      //bonyolultabb pl2.
      printf("%s\n", flag ? "OK" : "FAIL");
      //Formázott kiírás választott szöveggel.
    

      //bonyolultabb pl3.
      #define ABS(x) ((x) < 0 ? -(x) : (x))            
      //Érték-visszaadó „inline” funkció.
    

Vizsga kérdések

46. Ismertesse a „break” utasítás szerepét a „switch” utasításban!

      switch (c) {
        case 'a':
            puts("alma");
            break;              /* ← itt lépünk ki a switch-ből */
        case 'b':
            puts("banán");
            break;
    }
    puts("itt folytatjuk");     /* ide érkezik a vezérlés */
    
    

      //"fall through"
      switch (n) {
        case 1:
            puts("egy");
            /* nincs break → lefut a 2. ág kódja is */
        case 2:
            puts("kettő");
            break;
    }          
    

Vizsga kérdések

47. Ismertesse példával a C nyelvben alkalmazható bitműveleteket! Miért volt szükség logikai műveletekre a bitműveletek mellett?

      uint8_t flags = 0b00000101;   // bit0 = ON, bit2 = ON
      flags |= 0b00001000;          // 3. bit bekapcsolása (OR)
      flags &= ~0b00000001;         // 0. bit kikapcsolása (AND + NOT)
      if ((flags & 0b00001000) != 0) {
          /* a 3. bit most aktív */
      }
    

Vizsga kérdések

48. Ismertesse a C nyelv „pointer” fogalmát és az indirekció fogalmát!

int  n = 42;   /* egy normál egész */
int *p = &n;    /* p az n címe */

// egyszintű indirekció
int x  = 7;
int *px = &x;       // indirekt hozzáférés: *px
printf("%d", *px);  /* 7 */

// többszintű indirekció
int  v   = 3;
int *pv  = &v;      // &v → int*
int **ppv = &pv;    // &pv → int**
**ppv   = 99;       // két csillag: eljutunk v-ig
/* Dinamikus tömbök (char** argv), mátrixok, összefűzött listák fejmutatója,
   vagy olyan API-k, amelyek pointert várnak kimeneti paraméterként. */

int add(int a, int b) { return a + b; }
int (*op)(int,int) = add;// op egy függvény címe
int sum = op(2,3);       // indirekt hívás
        

Vizsga kérdések

49. Ismertesse a pointer aritmetikát!

        
        //1. Példa – lineáris bejárás

        int a[5] = {2,4,6,8,10};
        int *p = a;            // &a[0]
        while (p < a + 5) {    // one-past pointerig érvényes
            printf("%d ", *p); // dereferencia
            ++p;               // ugrás a következő int-re
        }                      // (4 bájttal 32-bitesen)
        
      

        
        //2. Példa – Különbség két pointer között

        double v[100];
        double *first = v + 20;
        double *last  = v + 80;
        ptrdiff_t elems = last - first;   // 60, nem 480 bájt
        
      

        
          //3. Példa – Különbség két pointer között
          
          double v[100];
          double *first = v + 20;
          double *last  = v + 80;
          ptrdiff_t elems = last - first;   // 60, nem 480 bájt
        
      

        
          //4. Példa – Szeletek
          
          int *begin = arr + start;
          int *end   = arr + end_excl;   // mutathat one-past-ra
          for (int *p = begin; p < end; ++p) process(*p);
        
      

        
          //5. Példa – Mutató + index
          
          size_t idx = 17;
          arr[idx] == *(arr + idx);   // teljesen azonos kód keletkezik
        
      

Vizsga kérdések

50. Ismertesse a tömbök használatánál előforduló komplexitás-típusokat! Mondjon példát arra a műveletre, amelyik adott komplexitású!

Vizsga kérdések

51. Ismertesse a tömbből való kicímzés veszélyeit!

Vizsga kérdések

52. Ismertesse a tömbök [] operátorának jelentését! Hogyan írható fel a [] operátor pointer aritmetikát felhasználva?

        
          E1[E2]
        
      

      
        * ( (E1) + (E2) )
      

    
    #include <stdio.h>
    int main(void)
    {
      int tomb[5] = { 1,2,3,4,5 };
      for (int i = 0; i < 5; i++) {
        printf("%d\t", tomb[i]);
        printf("%d\n", i[tomb]);
      }
      return 0;
    }
    
      

      
       1  1
       2  2
       3  3
       4  4
       5  5
       
        

Vizsga kérdések

54. Ismertesse a függvények írásának és paraméterezésének nyelvi szabályait a C nyelvben!

      
        visszateresi_ertek_tipusa függvény_név(típus első_paraméter, típus második_paraméter, ...)
        {
            /* függvénytörzs */
            /* ... */
            return érték;   /* ha a visszatérési_típus nem void */
        }        
      
    

      
        //Paraméternevek a prototípusban! (deklaráció) elhagyhatók:

        double hypot(double, double);   /* OK prototípus */

        //a definícióban kötelezőek.
      
    

Vizsga kérdések

55. Ismertesse a formális és aktuális paraméter fogalmát a C nyelv függvényeinél!

Vizsga kérdések

56. Milyen paraméter-átadást használ a C nyelv? Hogyan tudja megváltoztatni a függvény a paraméterei értékét úgy, hogy a hívó folyamatban is a változtatott érték szerepeljen?

Vizsga kérdések

57. Ismertesse a lokális és globális változó fogalmakat!

Bináris fileok

Bináris fileok

Egyszerű írási példa

      #include <stdio.h>
      #include <stdint.h>
      
      struct Record {            /* 12 bájt fix */
          uint32_t id;  float    value; /*4+4*/
          uint8_t  flag, pad[3];/*1+3, 4 bytera igazítás miatt pad*/
      };
      
      int main(void) {
          struct Record rec = { 42, 3.14f, 1 };
          FILE *f = fopen("data.bin", "wb");   /* b = binary */
          fwrite(&rec, sizeof rec, 1, f);             fclose(f);
          return 0;
      }
        

Bináris fileok

Egyszerű olvasási példa

      #include <stdio.h>
      #include <stdint.h>
      struct Record {...};
      
      int main(void) {
        FILE *f = fopen("data.bin", "rb");
        struct Record rec;
        if (fread(&rec, sizeof rec, 1, f) == 1) {
            printf("id=%u  value=%f  flag=%u\n",
                    rec.id, rec.value, rec.flag);
        }
        fclose(f);
        return 0;
        } 
        

Bináris fileok

data.bin hexadecimálisan

            00000000  2A 00 00 00  C3 F5 48 40  01 00 00 00

        

Teljesítménymérés

        #include <stdio.h>
        #include <time.h>
                
        int main(void) {
        clock_t start, stop;    double elteltIdo;
                
        start = clock();          // mérés kezdete   
                    // … Itt van a mérendő kódrész      
        stop  = clock();          // mérés vége
        elteltIdo = (double)(stop - start) / CLOCKS_PER_SEC;
        printf("Eltelt idő: %.6f s\n", elteltIdo);
                
        return 0;
        }                
        

Teljesítménymérés

Compiler

Teljesítménymérés

De mégis minek?

Teljesítménymérés

Compiler optimalizáció beállítás VS 2022-ben

Teljesítménymérés

VS 2022 optimalizációs opciók

Teljesítménymérés

Favor size vs favor speed

/O1 - Size

/O2 - Speed

Teljesítménymérés

Optimalizáció

Inlining

Teljesítménymérés

Optimalizáció

Loop-unrolling

          // Eredeti
          for(i=0; i<100; ++i) sum += a[i];
          
          // 4× unrolled
          for(i=0; i<100; i+=4) {
            sum += a[i];
            sum += a[i+1];
            sum += a[i+2];
            sum += a[i+3];
          }
          
            

Teljesítménymérés

Optimalizáció

Konstans-propagáció

          int x = 3;
          int y = x * 5 + 2;  // fordításkor -> int y = 17;          
            

Teljesítménymérés

Optimalizáció

Elágazás-átalakítás

Branch-unswitching

          
            for (…) {
              if (flag) { bodyA; } else { bodyB; }
            }                    
          
        

          
            if (flag) for (…) bodyA;
            else      for (…) bodyB;                            
          
        

Teljesítménymérés

Optimalizáció

Elágazás-átalakítás

Branch-fusion / coalescing

          
            // Eredeti:
            if (cond) {
                x = foo();
            }
            if (cond) {
                y = bar();
            }
            // Optimált (branch-fusion):
            if (cond) {
                x = foo();
                y = bar();
            }                               
          
        

Teljesítménymérés

Optimalizáció

Elágazás-átalakítás

Branch-prediction hint

          
            #include <stdbool.h>

              int process(int v, bool flag) {
                  // Hint: feltételezzük, hogy flag gyakrabban igaz
                  if (__builtin_expect(flag, 1)) {
                      // gyorsabb út, előnyben
                      return v * 2;
                  } else {
                      return v + 1;
                  }
              }                                          
          
        

Teljesítménymérés

Optimalizáció

Elágazás-átalakítás

Speculatív átalakítás

          
            // Eredeti:
            if (idx < N) {
                result = array[idx] * 10;
            }
            
            // Optimált (speculatív hoisting + mask):
            {
                int tmp = array[idx] * 10;  // mindig végrehajtjuk
                if (idx < N)
                    result = tmp;
                // ha idx>=N, tmp kiszámolása kidobódik
            }                                                     
          
        

C programteverzés, kódszervezés

C programteverzés, kódszervezés

Probléma megértése

Mi a bemenet?

Mi a kimenet?

Analóg problémák/újrahasznosítás

Papír-ceruza

C programteverzés, kódszervezés

Algoritmus tervezése

C programteverzés, kódszervezés

Modularizálás

C programteverzés, kódszervezés

Modularizálás - incomplete type pl.

C programteverzés, kódszervezés

Modularizálás - incomplete type pl.

        
          //civil.h
          #pragma once
          /* Csak előrejelzés*/
          typedef struct civil civil_t;
          /* Konstruktor / destruktor */
          civil_t *civil_create(int igazolvanyszam, int eletkor);
          void      civil_destroy(civil_t *c);
          /* Getterek */
          int   civil_get_igazolvanyszam(const civil_t *c);
          int   civil_get_eletkor      (const civil_t *c);
          double civil_get_karizma     (const civil_t *c);
          double civil_get_ero         (const civil_t *c);
          double civil_get_intelligencia(const civil_t *c);                                            
        
      

C programteverzés, kódszervezés

Modularizálás - incomplete type pl.

      
        //civil.c
        #include "civil.h"
        #include <stdlib.h>
        
        struct civil {
            int     igazolvanyszam,
                    eletkor;
            double  karizma,
                    ero,
                    intelligencia;
        };
        //függvénynek pointert kell visszaadnia
        civil_t *civil_create(int igazolvanyszam, int eletkor) { 
            civil_t *c = malloc(sizeof *c);
            if (!c) return NULL;
            c->igazolvanyszam  = igazolvanyszam;
            c->eletkor          = eletkor;
            c->karizma          = 1.0;    /* alapérték */
            c->ero              = 1.0;
            c->intelligencia    = 1.0;
            return c;
        }
        
        void civil_destroy(civil_t *c) {
            free(c);
        }
        
        int civil_get_igazolvanyszam(const civil_t *c) {
            return c->igazolvanyszam;
        }
        int civil_get_eletkor(const civil_t *c) {
            return c->eletkor;
        }
        double civil_get_karizma(const civil_t *c) {
            return c->karizma;
        }
        double civil_get_ero(const civil_t *c) {
            return c->ero;
        }
        double civil_get_intelligencia(const civil_t *c) {
            return c->intelligencia;
        }
                                                  
      
    

C programteverzés, kódszervezés

Modularizálás - incomplete type pl.

    
    //main.c
    #include <stdio.h>
    #include "civil.h"
    
    int main(void) {
        civil_t *c = civil_create(12345, 30);
        if (!c) return 1;
    
        printf("Igazolványszám: %d\n", civil_get_igazolvanyszam(c));
        printf("Életkor:          %d\n", civil_get_eletkor(c));
        printf("Karizma:          %.2f\n", civil_get_karizma(c));
        printf("Erő:              %.2f\n", civil_get_ero(c));
        printf("Intelligencia:    %.2f\n", civil_get_intelligencia(c));
    
        civil_destroy(c);
        return 0;
    }                                    
    
  

C programteverzés, kódszervezés

Adattípusok és struktúrák

C programteverzés, kódszervezés

Tesztelés

C programteverzés, kódszervezés

Optimalizálás