Home esercizi c allocazione dinamica memoria

Esercizi Allocazione Dinamica C

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;
}