Esercizi Allocazione Dinamica C
- Esercizio 1: Allocazione e Deallocazione di un Intero
- Esercizio 2: Allocazione e Deallocazione di un Array di Interi
- Esercizio 3: Allocazione e Deallocazione di una Matrice 2D
- Esercizio 4: Creazione e Deallocazione di una Struttura
- Esercizio 5: Allocazione e Deallocazione di un Array di Strutture
- Esercizio 6: Creazione e Deallocazione di una Stringa
- Esercizio 7: Creazione e Deallocazione di una Lista Collegata
- Esercizio 8: Creazione e Deallocazione di una Matrice Triangolare Inferiore
- Esercizio 9: Allocazione e Deallocazione di una Pila (Stack)
- Esercizio 10: Allocazione e Deallocazione di una Coda (Queue)
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;}