Esercizi Puntatori Avanzati in C

Ecco degli esercizi avanzati con soluzione per praticare l’uso dei puntatori in C.

Esercizio 1: Puntatori a Puntatori

Utilizzare puntatori a puntatori per modificare il valore di una variabile.

#include <stdio.h>

void modifica_valore(int **ptr) {
    **ptr = 10;
}

int main() {
    int x = 5;
    int *p = &x;
    int **pp = &p;

    modifica_valore(pp);

    printf("Valore di x: %d\n", x);  // Output: 10
    return 0;
}

Esercizio 2: Array di Puntatori

Utilizzare un array di puntatori per memorizzare e stampare una lista di stringhe.

#include <stdio.h>

int main() {
    const char *nomi[] = {"Alice", "Bob", "Charlie"};
    for (int i = 0; i < 3; i++) {
        printf("%s\n", nomi[i]);
    }
    return 0;
}

Esercizio 3: Puntatori a Funzione

Utilizzare puntatori a funzione per chiamare diverse funzioni in base a una condizione.

#include <stdio.h>

void saluta() {
    printf("Ciao!\n");
}

void addio() {
    printf("Addio!\n");
}

int main() {
    void (*funzione_ptr)();
    int condizione = 1;

    if (condizione) {
        funzione_ptr = saluta;
    } else {
        funzione_ptr = addio;
    }

    funzione_ptr();
    return 0;
}

Esercizio 4: Allocazione Dinamica di Matrici 2D

Allocare dinamicamente una matrice 2D e inizializzarla.

#include <stdio.h>
#include <stdlib.h>

int main() {
    int righe = 3, colonne = 4;
    int **matrice = (int **)malloc(righe * sizeof(int *));
    for (int i = 0; i < righe; i++) {
        matrice[i] = (int *)malloc(colonne * sizeof(int));
    }

    for (int i = 0; i < righe; i++) {
        for (int j = 0; j < colonne; j++) {
            matrice[i][j] = i * colonne + j;
        }
    }

    for (int i = 0; i < righe; i++) {
        for (int j = 0; j < colonne; j++) {
            printf("%d ", matrice[i][j]);
        }
        printf("\n");
    }

    for (int i = 0; i < righe; i++) {
        free(matrice[i]);
    }
    free(matrice);

    return 0;
}

Esercizio 5: Puntatori a Struct

Utilizzare un puntatore a struct per accedere e modificare i membri di una struct.

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int id;
    char nome[50];
} Persona;

int main() {
    Persona *p = (Persona *)malloc(sizeof(Persona));
    p->id = 1;
    snprintf(p->nome, sizeof(p->nome), "Mario");

    printf("ID: %d, Nome: %s\n", p->id, p->nome);

    free(p);
    return 0;
}

Esercizio 6: Puntatori a Costanti

Utilizzare un puntatore a costante per garantire che il valore puntato non possa essere modificato.

#include <stdio.h>

int main() {
    int x = 10;
    const int *ptr = &x;

    printf("Valore di x: %d\n", *ptr);
    // *ptr = 20; // Errore: non è possibile modificare il valore puntato

    x = 20; // Questo è permesso
    printf("Nuovo valore di x: %d\n", *ptr);

    return 0;
}

Esercizio 7: Modifica di una Stringa usando Puntatori

Utilizzare un puntatore per modificare i caratteri di una stringa.

#include <stdio.h>

int main() {
    char str[] = "Ciao, mondo!";
    char *ptr = str;

    while (*ptr != '\0') {
        if (*ptr == 'o') {
            *ptr = '0'; // Sostituisci 'o' con '0'
        }
        ptr++;
    }

    printf("Stringa modificata: %s\n", str);
    return 0;
}

Esercizio 8: Puntatori a Variabili Volatili

Utilizzare un puntatore a una variabile volatile per accedere a una variabile che può essere modificata da un'interruzione.

#include <stdio.h>

volatile int flag = 0;

void interrupt_handler() {
    flag = 1;
}

int main() {
    int *ptr = (int *)&flag;

    // Simulazione di un'interruzione
    interrupt_handler();

    if (*ptr) {
        printf("Interruzione rilevata!\n");
    }

    return 0;
}

Esercizio 9: Puntatori a Funzione per Calcolatrice

Utilizzare puntatori a funzione per implementare una semplice calcolatrice.

#include <stdio.h>

int somma(int a, int b) {
    return a + b;
}

int sottrazione(int a, int b) {
    return a - b;
}

int moltiplicazione(int a, int b) {
    return a * b;
}

int divisione(int a, int b) {
    if (b != 0) {
        return a / b;
    } else {
        printf("Errore: divisione per zero\n");
        return 0;
    }
}

int main() {
    int (*operazione)(int, int);
    char operatore;
    int a = 10, b = 5;

    printf("Inserisci un'operazione (+, -, *, /): ");
    scanf(" %c", &operatore);

    switch (operatore) {
        case '+':
            operazione = somma;
            break;
        case '-':
            operazione = sottrazione;
            break;
        case '*':
            operazione = moltiplicazione;
            break;
        case '/':
            operazione = divisione;
            break;
        default:
            printf("Operatore non valido\n");
            return 1;
    }

    printf("Risultato: %d\n", operazione(a, b));
    return 0;
}

Esercizio 10: Array Dinamico di Puntatori a Stringhe

Creare un array dinamico di puntatori a stringhe e aggiungere stringhe dinamicamente.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    char **str_array = NULL;
    int n = 0;
    char buffer[100];

    while (1) {
        printf("Inserisci una stringa (digita 'fine' per terminare): ");
        scanf("%99s", buffer);

        if (strcmp(buffer, "fine") == 0) {
            break;
        }

        str_array = (char **)realloc(str_array, (n + 1) * sizeof(char *));
        str_array[n] = (char *)malloc((strlen(buffer) +

1) * sizeof(char));
        strcpy(str_array[n], buffer);
        n++;
    }

    printf("Stringhe inserite:\n");
    for (int i = 0; i < n; i++) {
        printf("%s\n", str_array[i]);
        free(str_array[i]);
    }

    free(str_array);
    return 0;
}