Responsabili

• Iulia Corici
• Banu Maximilian

În cadrul acestui laborator ne propunem să recapitulăm cateva dintre conceptele de C invatate la cursul de Programarea Calculatoarelor.

Ne dorim să:

• Recapitulăm alocarea dinamică a memoriei și pointerii
• Recapitulăm lucrul cu structuri
• Recapitulăm directivele de preprocesare
• Recapitulăm cum ne asigurăm ca nu avem memory leaks în programul nostru

C este un limbaj pass-by-value. Asta înseamnă ca funcțiile își vor crea copii ale parametrilor și vor lucra cu ele. Dacă vrem să lucram direct pe variabilele trimise ca parametru, va trebui să trimitem adresa lor către funcție.

main.c

#include <stdio.h>
 
// Se va face câte o copie a variabilelor a și b. Aceste copii se vor distruge
// după ce funcția își va încheia execuția
void swap(int a, int b) {
     int temp = a;
     a = b;
     b = a;
}
 
// Se va face câte o copie a pointerilor dar vor pointa tot către variabilele
// a și b
void swap2(int* a, int* b) {
     int temp = *a;
     *a = *b;
     *b = temp;
}
 
int main() {
     int a = 5;
     int b = 10;
 
     printf("Before swap: %d %d\n", a, b); // 5 10
     swap(a, b);
     printf("After swap: %d %d\n", a, b); // 5 10
 
 
     printf("Before swap: %d %d\n", a, b); // 5 10
     swap2(&a, &b);
     printf("After swap: %d %d\n", a, b); // 10 5
 
     return 0;
}

Un pointer de tipul void* este un pointer care nu este asociat cu niciun tip de date, ceea ce îi permite să pointeze la adrese de memorie de orice tip. De asemenea, el poate fi specializat (cast) la orice tip de date.

main.c

#include <stdio.h>
 
enum types {
   INT,
   DOUBLE,
   STRING
};
 
void print(void* var, enum types type) {
   if (type == INT) {
       printf("%d\n", *((int*)var));
   }
   if (type == DOUBLE) {
       printf("%lf\n", *((double*)var));
   }
   if (type == STRING) {
       printf("%s\n", (char*)var);
   }
}
 
int main() {
   int a = 123;
   double b = 2.67;
   char* c = "wubba lubba dub dub";
 
   print(&a, INT);
   print(&b, DOUBLE);
   print(c, STRING);
 
   return 0;
}

Printr-un vector se înţelege o colecţie liniară şi omogenă de date. Un vector este liniar pentru că datele (elementele) pot fi accesate în mod unic printr-un index. Un vector este, de asemenea, omogen, pentru că toate elementele sunt de acelaşi tip. În limbajul C, indexul este un număr întreg pozitiv şi indexarea se face începând cu 0.

Declarare vector static:

int a[100]; // declarare statică: dimensiunea acestui vector trebuie să fie o constantă 
            // la compilare şi nu poate fi modificată în cursul execuţiei programului.

Declarare vector alocat dinamic:

int *a = malloc(n * sizeof(*a));
…
free(a);

În limbajul C nu există la nivel de sintaxă nicio diferenţă între utilizarea unui vector cu dimensiune fixă şi utilizarea unui vector alocat dinamic.

#include <errno.h>
#define DIE(assertion, call_description)				\
        do {								\
                if (assertion) {					\
                        fprintf(stderr, "(%s, %d): ",			\
                                        __FILE__, __LINE__);		\
                        perror(call_description);			\
                        exit(errno);					\
                }							\
        } while (0)

Matricea este o colecţie omogenă şi bidimensională de elemente. Acestea pot fi accesate prin intermediul a doi indici, numerotaţi, ca şi în cazul vectorilor, începând de la 0.

Declarare matrice statica:

int mat[5][10];

Declarare matrice dinamică:

int **a;
...
a = malloc(nl * sizeof(int *));   // Alocare pentru vector de pointeri
for (i = 0; i < nl; ++i) {
   a[i] = malloc(nc * sizeof(int));  // Alocare pentru o linie
}
...
for (i = 0; i < nl; ++i) {
     free(a[i]);
}
free(a);

Dacă se cunoaște la compilare prima dimensiune a matricei (numărul de linii), un alt mod de a declara o matrice dinamic este următorul:

int (*mat)[10] = malloc(sizeof(*mat) * 5);
...
free(mat);

Redimensionarea unui vector care crește (sau scade) față de dimensiunea alocată inițial se poate face cu funcţia realloc, care primeşte adresa veche şi noua dimensiune şi întoarce noua adresă.

Variabilele statice reprezintă un tip special de variabile care sunt stocate într-o parte separată a memoriei, astfel încât să fie vizibile oriunde în program. Acestea au avantajul că dacă sunt declarate într-o funcție și apoi modificate, acele modificări vor fi vizibile și la următorul apel al funcției, spre deosebire de variabilele locale obișnuite.

#include <stdio.h>
void f() {
    static int i = 0;
    ++i;
    printf("%d ", i);
}
 
int main() {
    for (int i = 0; i < 3; ++i) {
        f();
    }
 
    return 0;
}

Declararea unei funcții ca fiind statică îi va restricționa acesteia accesul la fișierul în care este declarată. Astfel, dacă fișierul sursă al acesteia este inclus în altul iar funcția respectivă este apelată din el, vom primi o eroare de compilare, funcția statică nefiind inclusă.

f1.c

static void f() {
    printf(“imported”);
}

f2.c

#include “f1.c”;
 
int main() {
    f(); // Se va genera o eroare de tip “undefinied reference to f” deoarece funcția statică nu a fost importata.
    return 0;
}

Keyword-ul const desemnează o variabilă constantă, read-only, a cărei valoare nu se va mai schimba după actualizare. Cand se incearca schimbarea valorii, se va genera o eroare de compilare. În cazul pointerilor fiți atenți dacă adresa de memorie este cea constantă sau valoarea spre care pointeaza!

Deducerea acestor declarări se poate face prin clockwise/spiral rule.

Exemple:

int* a; // pointer de tip int
int* const a; // pointer constant catre un int variabil
int const *a; // pointer variabil catre un int constant
int const * const a; // pointer constant catre un int constant

const int* a == int const* a (veți vedea de multe ori acest tip de declarare)

#define MAX 50

Putem defini constante ce vor fi înlocuite peste tot în program în etapa de preprocesare. Este recomandat să folosim aceasta optiune în defavoarea scrierii efective a constantei deoarece suntem mai predispuși la buguri putând uita sa modificăm constanta în unele părți ale programului.

Folosim gărzi de preprocesare pentru a evita incluziunea multiplă și redefinirea de variabile. Astfel, chiar dacă includem de mai multe ori același header, textual, vom avea o singura înlocuire a variabilelor/funcțiilor.

engine.h

struct A{};

car.h

car.h
#include “engine.h” // se va înlocui cu struct A la preprocesare

main.c

#include “engine.h”
#include “car.h”
 
...// Vom avea inclusă de două ori struct A, ceea ce va duce la o eroare de compilare
   // deoarece se încearcă redefinirea lui A.

Solutie: Adăugăm gărzi în fiecare fișier

engine.h

#ifndef __ENGINE_H__
#define __ENGINE_H__
 
struct A {};
 
#endif

car.h

#ifndef __CAR_H__
#define __CAR_H__
 
#include "engine.h"
 
#endif

main.c

#include "engine.h"
#include "car.h"
 
int main() {
    return 0;
}

După expandare vom avea:

main.c

#ifndef __ENGINE_H__ // Adăugăm o intrare pentru "engine" în tabela de simboluri
#define __ENGINE_H__
 
struct A {};
 
#endif
 
#ifndef __CAR_H__ // Adăugăm o intrare pentru "car" in tabela de simboluri
#define __CAR_H__
 
#ifndef __ENGINE_H__ // "engine" este definit deci sărim peste acest branch și nu includem struct A din nou
#define __ENGINE_H__
 
struct A {};
 
#endif
 
#endif
 
int main() {
    return 0;
}

Scheletul de laborator

Enunțurile problemelor le găsiți pe Lambda Checker, aici. Tot acolo veți și încărca soluțiile voastre.

Această secțiune nu este punctată și încearcă să vă facă o oarecare idee a tipurilor de întrebări pe care le puteți întâlni la un job interview (internship, part-time, full-time, etc.) din materia prezentată în cadrul laboratorului.

• Care este diferența dintre pass by value si pass by address?
• Ce întoarce funcția malloc? De ce?
• Care sunt diferențele dintre alocarea dinamică și alocarea statică?
• Ce se întâmplă dacă un header este inclus de două ori?

Și multe altele…

1. Cum scriem cod C corect?
2. Valgrind quick start

1. Tutorial C pentru începători
2. The C Programming Language by K&R