🚀 Nuova versione beta disponibile! Feedback o problemi? Contattaci

Esercizi Union in C

Codegrind Team•Jul 12 2024

Ecco degli esercizi con soluzione per praticare l’uso delle union in C.

Esercizio 1: Definizione e Uso di una Union

Definire una union con diversi tipi di dati e assegnare un valore a ciascun membro. 
#include <stdio.h>

union Dati {
    int i;
    float f;
    char c;
};

int main() {
    union Dati dato;
    dato.i = 10;
    printf("Intero: %d\n", dato.i);
    dato.f = 3.14;
    printf("Float: %f\n", dato.f);
    dato.c = 'A';
    printf("Char: %c\n", dato.c);
    return 0;
}

Esercizio 2: Uso di Union per Risparmiare Memoria

Utilizzare una union per risparmiare memoria tra diversi tipi di dati. 
#include <stdio.h>
#include <string.h>

union Dati {
    int i;
    float f;
    char str[20];
};

int main() {
    union Dati dato;
    printf("Dimensione di union Dati: %lu\n", sizeof(dato));

    dato.i = 10;
    printf("Intero: %d\n", dato.i);

    dato.f = 3.14;
    printf("Float: %f\n", dato.f);

    strcpy(dato.str, "Hello");
    printf("Stringa: %s\n", dato.str);

    return 0;
}

Esercizio 3: Union all’interno di una Struct

Definire una struct che contiene una union e accedere ai suoi membri. 
#include <stdio.h>
#include <string.h>

struct Contenitore {
    char tipo;
    union {
        int i;
        float f;
        char str[20];
    } dato;
};

int main() {
    struct Contenitore cont;
    cont.tipo = 'i';
    cont.dato.i = 100;
    if (cont.tipo == 'i') {
        printf("Intero: %d\n", cont.dato.i);
    }

    cont.tipo = 'f';
    cont.dato.f = 3.14;
    if (cont.tipo == 'f') {
        printf("Float: %f\n", cont.dato.f);
    }

    cont.tipo = 's';
    strcpy(cont.dato.str, "Ciao");
    if (cont.tipo == 's') {
        printf("Stringa: %s\n", cont.dato.str);
    }

    return 0;
}

Esercizio 4: Confronto tra Union e Struct

Confrontare la dimensione di una union e di una struct con gli stessi membri. 
#include <stdio.h>

union DatiUnion {
    int i;
    float f;
    char c;
};

struct DatiStruct {
    int i;
    float f;
    char c;
};

int main() {
    union DatiUnion u;
    struct DatiStruct s;

    printf("Dimensione di union: %lu\n", sizeof(u));
    printf("Dimensione di struct: %lu\n", sizeof(s));

    return 0;
}

Esercizio 5: Uso di Union per Conversione di Tipi

Utilizzare una union per convertire tra tipi di dati diversi. 
#include <stdio.h>

union Convertitore {
    int i;
    float f;
};

int main() {
    union Convertitore conv;
    conv.i = 1078523331;  // Bit pattern equivalente a 3.14 in float
    printf("Intero: %d\n", conv.i);
    printf("Float: %f\n", conv.f);
    return 0;
}

Esercizio 6: Union per Archiviazione di Dati Eterogenei

Utilizzare una union per archiviare e accedere a dati eterogenei. 
#include <stdio.h>

union Dati {
    int intero;
    float decimale;
    char carattere;
};

void stampaDati(union Dati d, char tipo) {
    if (tipo == 'i') {
        printf("Intero: %d\n", d.intero);
    } else if (tipo == 'f') {
        printf("Float: %f\n", d.decimale);
    } else if (tipo == 'c') {
        printf("Carattere: %c\n", d.carattere);
    }
}

int main() {
    union Dati d;
    d.intero = 100;
    stampaDati(d, 'i');

    d.decimale = 3.14;
    stampaDati(d, 'f');

    d.carattere = 'A';
    stampaDati(d, 'c');

    return 0;
}

Esercizio 7: Uso di Union con Array

Utilizzare una union con un array per accedere ai dati in modo diverso. 
#include <stdio.h>

union Dati {
    int interi[2];
    float decimali[2];
};

int main() {
    union Dati d;

    d.interi[0] = 1;
    d.interi[1] = 2;
    printf("Interi: %d, %d\n", d.interi[0], d.interi[1]);

    d.decimali[0] = 3.14;
    d.decimali[1] = 6.28;
    printf("Float: %f, %f\n", d.decimali[0], d.decimali[1]);

    return 0;
}

Esercizio 8: Union con Enum per Tipo di Dato

Utilizzare una union con un enum per determinare il tipo di dato archiviato. 
#include <stdio.h>

enum TipoDato { INTERO, DECIMALE, CARATTERE };

union Dati {
    int intero;
    float decimale;
    char carattere;
};

void stampaDati(union Dati d, enum TipoDato tipo) {
    switch (tipo) {
        case INTERO:
            printf("Intero: %d\n", d.intero);
            break;
        case DECIMALE:
            printf("Float: %f\n", d.decimale);
            break;
        case CARATTERE:
            printf("Carattere: %c\n", d.carattere);
            break;
    }
}

int main() {
    union Dati d;
    enum TipoDato tipo;

    d.intero = 100;
    tipo = INTERO;
    stampaDati(d, tipo);

    d.decimale = 3.14;
    tipo = DECIMALE;
    stampaDati(d, tipo);

    d.carattere = 'A';
    tipo = CARATTERE;
    stampaDati(d, tipo);

    return 0;
}

Esercizio 9: Accesso ai Membri di una Union con Puntatori

Utilizzare puntatori per accedere ai membri di una union. 
#include <stdio.h>

union Dati {
    int intero;
    float decimale;
    char carattere;
};

int main() {
    union Dati d;
    d.intero = 100;

    int *pIntero = &d.intero;
    printf("Intero tramite puntatore: %d\n", *pIntero);

    d.decimale = 3.14;
    float *pDecimale = &d.decimale;
    printf("Float tramite puntatore: %f\n", *pDecimale);

    d.carattere = 'A';
    char *pCarattere = &d.carattere;
    printf("Carattere tramite puntatore: %c\n", *pCarattere);

    return 0

;
}

Esercizio 10: Uso di Union in una Funzione

Passare una union a una funzione e modificarne il contenuto. 
#include <stdio.h>

union Dati {
    int intero;
    float decimale;
    char carattere;
};

void modificaUnion(union Dati *d, int tipo) {
    switch (tipo) {
        case 0:
            d->intero = 200;
            break;
        case 1:
            d->decimale = 6.28;
            break;
        case 2:
            d->carattere = 'B';
            break;
    }
}

int main() {
    union Dati d;

    modificaUnion(&d, 0);
    printf("Intero: %d\n", d.intero);

    modificaUnion(&d, 1);
    printf("Float: %f\n", d.decimale);

    modificaUnion(&d, 2);
    printf("Carattere: %c\n", d.carattere);

    return 0;
}
PrecedenteStructureSuccessivoEnum