Esercizi Allocazione Dinamica C
Codegrind Team•Jul 12 2024
Ecco degli esercizi semplici con soluzione per praticare le basi dell’allocazione dinamica della memoria in C.
Esercizio 1: Allocazione e Deallocazione di un Intero
Allocare dinamicamente un intero, assegnare un valore e deallocarlo.
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr = (int *)malloc(sizeof(int));
if (ptr == NULL) {
printf("Errore di allocazione della memoria\n");
return 1;
}
*ptr = 42;
printf("Valore: %d\n", *ptr);
free(ptr);
printf("Memoria deallocata\n");
return 0;
}
Esercizio 2: Allocazione e Deallocazione di un Array di Interi
Allocare dinamicamente un array di interi, assegnare valori e deallocarlo.
#include <stdio.h>
#include <stdlib.h>
int main() {
int *arr = (int *)malloc(5 * sizeof(int));
if (arr == NULL) {
printf("Errore di allocazione della memoria\n");
return 1;
}
for (int i = 0; i < 5; ++i) {
arr[i] = i + 1;
}
for (int i = 0; i < 5; ++i) {
printf("arr[%d] = %d\n", i, arr[i]);
}
free(arr);
printf("Memoria deallocata\n");
return 0;
}
Esercizio 3: Allocazione e Deallocazione di una Matrice 2D
Allocare dinamicamente una matrice 2D di interi, assegnare valori e deallocarla.
#include <stdio.h>
#include <stdlib.h>
int main() {
int rows = 3;
int cols = 3;
int **matrix = (int **)malloc(rows * sizeof(int *));
if (matrix == NULL) {
printf("Errore di allocazione della memoria\n");
return 1;
}
for (int i = 0; i < rows; ++i) {
matrix[i] = (int *)malloc(cols * sizeof(int));
if (matrix[i] == NULL) {
printf("Errore di allocazione della memoria\n");
return 1;
}
}
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
matrix[i][j] = i * cols + j;
}
}
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
for (int i = 0; i < rows; ++i) {
free(matrix[i]);
}
free(matrix);
printf("Memoria deallocata\n");
return 0;
}
Esercizio 4: Creazione e Deallocazione di una Struttura
Allocare dinamicamente una struttura, assegnare valori e deallocarla.
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int x;
int y;
} Punto;
int main() {
Punto *p = (Punto *)malloc(sizeof(Punto));
if (p == NULL) {
printf("Errore di allocazione della memoria\n");
return 1;
}
p->x = 10;
p->y = 20;
printf("Punto: (%d, %d)\n", p->x, p->y);
free(p);
printf("Memoria deallocata\n");
return 0;
}
Esercizio 5: Allocazione e Deallocazione di un Array di Strutture
Allocare dinamicamente un array di strutture, assegnare valori e deallocarlo.
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int x;
int y;
} Punto;
int main() {
Punto *arr = (Punto *)malloc(3 * sizeof(Punto));
if (arr == NULL) {
printf("Errore di allocazione della memoria\n");
return 1;
}
arr[0] = (Punto){1, 2};
arr[1] = (Punto){3, 4};
arr[2] = (Punto){5, 6};
for (int i = 0; i < 3; ++i) {
printf("Punto %d: (%d, %d)\n", i, arr[i].x, arr[i].y);
}
free(arr);
printf("Memoria deallocata\n");
return 0;
}
Esercizio 6: Creazione e Deallocazione di una Stringa
Allocare dinamicamente una stringa, assegnare un valore e deallocarla.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
char *str = (char *)malloc(50 * sizeof(char));
if (str == NULL) {
printf("Errore di allocazione della memoria\n");
return 1;
}
strcpy(str, "Hello, world!");
printf("Stringa: %s\n", str);
free(str);
printf("Memoria deallocata\n");
return 0;
}
Esercizio 7: Creazione e Deallocazione di una Lista Collegata
Allocare dinamicamente una lista collegata di nodi, assegnare valori e deallocarla.
#include <stdio.h>
#include <stdlib.h>
typedef struct Nodo {
int dato;
struct Nodo* prossimo;
} Nodo;
int main() {
Nodo* testa = (Nodo*)malloc(sizeof(Nodo));
if (testa == NULL) {
printf("Errore di allocazione della memoria\n");
return 1;
}
testa->dato = 1;
testa->prossimo = (Nodo*)malloc(sizeof(Nodo));
if (testa->prossimo == NULL) {
printf("Errore di allocazione della memoria\n");
free(testa);
return 1;
}
testa->prossimo->dato = 2;
testa->prossimo->prossimo = (Nodo*)malloc(sizeof(Nodo));
if (testa->prossimo->prossimo == NULL) {
printf("Errore di allocazione della memoria\n");
free(testa->prossimo);
free(testa);
return 1;
}
testa->prossimo->prossimo->dato = 3;
testa->prossimo->prossimo->prossimo = NULL;
Nodo* current = testa;
while (current) {
printf("%d ", current->dato);
Nodo* daCancellare = current;
current = current->prossimo;
free(daCancellare);
}
printf("\nMemoria deallocata\n");
return 0;
}
Esercizio 8: Creazione e Deallocazione di una Matrice Triangolare Inferiore
Allocare dinamicamente una matrice triangolare inferiore, assegnare valori e deallocarla.
#include <stdio.h>
#include <stdlib.h>
int main() {
int n = 5;
int** triangolare = (int**)malloc(n * sizeof(int*));
if (triangolare == NULL) {
printf("Errore di allocazione della memoria\n");
return 1;
}
for (int i =
0; i < n; ++i) {
triangolare[i] = (int*)malloc((i + 1) * sizeof(int));
if (triangolare[i] == NULL) {
printf("Errore di allocazione della memoria\n");
return 1;
}
for (int j = 0; j <= i; ++j) {
triangolare[i][j] = (i + 1) * (j + 1);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= i; ++j) {
printf("%d ", triangolare[i][j]);
}
printf("\n");
}
for (int i = 0; i < n; ++i) {
free(triangolare[i]);
}
free(triangolare);
printf("Memoria deallocata\n");
return 0;
}
Esercizio 9: Allocazione e Deallocazione di una Pila (Stack)
Allocare dinamicamente una pila, eseguire operazioni di push e pop e deallocare la memoria.
#include <stdio.h>
#include <stdlib.h>
typedef struct Nodo {
int dato;
struct Nodo* prossimo;
} Nodo;
typedef struct {
Nodo* cima;
} Pila;
void push(Pila* pila, int val) {
Nodo* nuovoNodo = (Nodo*)malloc(sizeof(Nodo));
if (nuovoNodo == NULL) {
printf("Errore di allocazione della memoria\n");
return;
}
nuovoNodo->dato = val;
nuovoNodo->prossimo = pila->cima;
pila->cima = nuovoNodo;
}
int pop(Pila* pila) {
if (pila->cima == NULL) {
printf("Pila vuota!\n");
exit(1);
}
Nodo* nodoDaCancellare = pila->cima;
int val = nodoDaCancellare->dato;
pila->cima = pila->cima->prossimo;
free(nodoDaCancellare);
return val;
}
int main() {
Pila pila = { NULL };
push(&pila, 1);
push(&pila, 2);
push(&pila, 3);
printf("Pop: %d\n", pop(&pila));
printf("Pop: %d\n", pop(&pila));
printf("Pop: %d\n", pop(&pila));
printf("Memoria deallocata\n");
return 0;
}
Esercizio 10: Allocazione e Deallocazione di una Coda (Queue)
Allocare dinamicamente una coda, eseguire operazioni di enqueue e dequeue e deallocare la memoria.
#include <stdio.h>
#include <stdlib.h>
typedef struct Nodo {
int dato;
struct Nodo* prossimo;
} Nodo;
typedef struct {
Nodo* testa;
Nodo* coda;
} Coda;
void enqueue(Coda* coda, int val) {
Nodo* nuovoNodo = (Nodo*)malloc(sizeof(Nodo));
if (nuovoNodo == NULL) {
printf("Errore di allocazione della memoria\n");
return;
}
nuovoNodo->dato = val;
nuovoNodo->prossimo = NULL;
if (coda->coda == NULL) {
coda->testa = nuovoNodo;
} else {
coda->coda->prossimo = nuovoNodo;
}
coda->coda = nuovoNodo;
}
int dequeue(Coda* coda) {
if (coda->testa == NULL) {
printf("Coda vuota!\n");
exit(1);
}
Nodo* nodoDaCancellare = coda->testa;
int val = nodoDaCancellare->dato;
coda->testa = coda->testa->prossimo;
if (coda->testa == NULL) {
coda->coda = NULL;
}
free(nodoDaCancellare);
return val;
}
int main() {
Coda coda = { NULL, NULL };
enqueue(&coda, 1);
enqueue(&coda, 2);
enqueue(&coda, 3);
printf("Dequeue: %d\n", dequeue(&coda));
printf("Dequeue: %d\n", dequeue(&coda));
printf("Dequeue: %d\n", dequeue(&coda));
printf("Memoria deallocata\n");
return 0;
}