Esercizi Allocazione Dinamica C++

Codegrind Team•Jul 12 2024

Ecco degli esercizi semplici con soluzione per praticare le basi dell’allocazione dinamica in C++.

Esercizio 1

Allocare dinamicamente un intero e stamparne il valore.

#include <iostream>

int main() {
    int* ptr = new int;
    *ptr = 42;
    std::cout << "Valore dell'intero: " << *ptr << std::endl;
    delete ptr;
    return 0;
}

Esercizio 2

Allocare dinamicamente un array di interi e inizializzarlo con valori da 1 a 5.

#include <iostream>

int main() {
    int* arr = new int[5];
    for (int i = 0; i < 5; ++i) {
        arr[i] = i + 1;
    }
    for (int i = 0; i < 5; ++i) {
        std::cout << "arr[" << i << "] = " << arr[i] << std::endl;
    }
    delete[] arr;
    return 0;
}

Esercizio 3

Allocare dinamicamente una matrice 3x3 e inizializzarla con valori incrementali.

#include <iostream>

int main() {
    int** matrix = new int*[3];
    for (int i = 0; i < 3; ++i) {
        matrix[i] = new int[3];
    }
    int val = 1;
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            matrix[i][j] = val++;
        }
    }
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
    for (int i = 0; i < 3; ++i) {
        delete[] matrix[i];
    }
    delete[] matrix;
    return 0;
}

Esercizio 4

Utilizzare l'allocazione dinamica per creare una copia di un array esistente.

#include <iostream>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int* copy = new int[5];
    for (int i = 0; i < 5; ++i) {
        copy[i] = arr[i];
    }
    for (int i = 0; i < 5; ++i) {
        std::cout << "copy[" << i << "] = " << copy[i] << std::endl;
    }
    delete[] copy;
    return 0;
}

Esercizio 5

Allocare dinamicamente una stringa e copiarvi una stringa esistente.

#include <iostream>
#include <cstring>

int main() {
    const char* original = "Ciao, mondo!";
    char* copy = new char[strlen(original) + 1];
    strcpy(copy, original);
    std::cout << "Copia della stringa: " << copy << std::endl;
    delete[] copy;
    return 0;
}

Esercizio 6

Allocare dinamicamente un array di strutture e inizializzarlo.

#include <iostream>

struct Punto {
    int x, y;
};

int main() {
    Punto* punti = new Punto[3];
    punti[0] = {1, 2};
    punti[1] = {3, 4};
    punti[2] = {5, 6};
    for (int i = 0; i < 3; ++i) {
        std::cout << "Punto " << i << ": (" << punti[i].x << ", " << punti[i].y << ")" << std::endl;
    }
    delete[] punti;
    return 0;
}

Esercizio 7

Utilizzare l'allocazione dinamica per gestire una lista collegata.

#include <iostream>

struct Nodo {
    int dato;
    Nodo* prossimo;
};

int main() {
    Nodo* testa = new Nodo{1, nullptr};
    testa->prossimo = new Nodo{2, nullptr};
    testa->prossimo->prossimo = new Nodo{3, nullptr};
    Nodo* current = testa;
    while (current) {
        std::cout << current->dato << " ";
        Nodo* daCancellare = current;
        current = current->prossimo;
        delete daCancellare;
    }
    std::cout << std::endl;
    return 0;
}

Esercizio 8

Allocare dinamicamente una matrice triangolare inferiore.

#include <iostream>

int main() {
    int n = 5;
    int** triangolare = new int*[n];
    for (int i = 0; i < n; ++i) {
        triangolare[i] = new int[i + 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) {
            std::cout << triangolare[i][j] << " ";
        }
        std::cout << std::endl;
    }
    for (int i = 0; i < n; ++i) {
        delete[] triangolare[i];
    }
    delete[] triangolare;
    return 0;
}

Esercizio 9

Utilizzare l'allocazione dinamica per creare una struttura dati per una coda.

#include <iostream>

struct Nodo {
    int dato;
    Nodo* prossimo;
};

class Coda {
private:
    Nodo* testa;
    Nodo* coda;

public:
    Coda() : testa(nullptr), coda(nullptr) {}

    void enqueue(int val) {
        Nodo* nuovoNodo = new Nodo{val, nullptr};
        if (coda) {
            coda->prossimo = nuovoNodo;
        } else {
            testa = nuovoNodo;
        }
        coda = nuovoNodo;
    }

    int dequeue() {
        if (!testa) {
            throw std::runtime_error("Coda vuota!");
        }
        int val = testa->dato;
        Nodo* daCancellare = testa;
        testa = testa->prossimo;
        if (!testa) {
            coda = nullptr;
        }
        delete daCancellare;
        return val;
    }

    ~Coda() {
        while (testa) {
            Nodo* daCancellare = testa;
            testa = testa->prossimo;
            delete daCancellare;
        }
    }
};

int main() {
    Coda coda;
    coda.enqueue(1);
    coda.enqueue(2);
    coda.enqueue(3);
    std::cout << "Dequeue: " << coda.dequeue() << std::endl;
    std::cout << "Dequeue: " << coda.dequeue

() << std::endl;
    std::cout << "Dequeue: " << coda.dequeue() << std::endl;
    return 0;
}

Esercizio 10

Utilizzare l'allocazione dinamica per creare una pila (stack).

#include <iostream>

struct Nodo {
    int dato;
    Nodo* prossimo;
};

class Pila {
private:
    Nodo* cima;

public:
    Pila() : cima(nullptr) {}

    void push(int val) {
        Nodo* nuovoNodo = new Nodo{val, cima};
        cima = nuovoNodo;
    }

    int pop() {
        if (!cima) {
            throw std::runtime_error("Pila vuota!");
        }
        int val = cima->dato;
        Nodo* daCancellare = cima;
        cima = cima->prossimo;
        delete daCancellare;
        return val;
    }

    ~Pila() {
        while (cima) {
            Nodo* daCancellare = cima;
            cima = cima->prossimo;
            delete daCancellare;
        }
    }
};

int main() {
    Pila pila;
    pila.push(1);
    pila.push(2);
    pila.push(3);
    std::cout << "Pop: " << pila.pop() << std::endl;
    std::cout << "Pop: " << pila.pop() << std::endl;
    std::cout << "Pop: " << pila.pop() << std::endl;
    return 0;
}