This code mixes concepts of structs, unions, and user input...

August 22, 2025 at 05:22 PM

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

// Dichiaro le struct client e ordine usate
typedef struct {
  char nome[20];
  char cognome[20];
  char indirizzo[20];
  int eta;
} Cliente;

typedef struct {
  char prodotto[20];
  char codiceid[20];
  double prezzo;
} Ordine;

// Dichiaro l'unione di client e ordine
union Registro {
  Cliente client;
  Ordine ordine;
};

// Metodo dove avviene il type confusion tratto tutti i dati come Ordine
void stampaOrdine(union Registro* reg) {
  printf("Prodotto: %s\nCodice Identificativo: %s \nPrezzo: %.2f\n", reg->ordine.prodotto, reg->ordine.codiceid, reg->ordine.prezzo);
}

int main() {
  union Registro reg;
  
  // Chiedo il tipo di variabili da inserire
  char scelta[20];
  printf("Vuoi aggiungere: Cliente o Ordine? \n");
  fgets(scelta, sizeof(scelta), stdin);
  scelta[strcspn(scelta, "\n")] = 0;
  
  // Se controllo e prendo in input il tipo d dato scelto dal cliente
  if (strcmp(scelta, "Cliente") == 0 || strcmp(scelta, "cliente") == 0) {
    printf("Nome: ");
    fgets(reg.client.nome, sizeof(reg.client.nome), stdin);
    reg.client.nome[strcspn(reg.client.nome, "\n")] = 0;
    printf("Cognome: ");
    fgets(reg.client.cognome, sizeof(reg.client.cognome), stdin);
    reg.client.cognome[strcspn(reg.client.cognome, "\n")] = 0;
    printf("Indirizzo: ");
    fgets(reg.client.indirizzo, sizeof(reg.client.indirizzo), stdin);
    reg.client.indirizzo[strcspn(reg.client.indirizzo, "\n")] = 0;
    printf("Eta: ");
    scanf("%d", &reg.client.eta);
  } else if (strcmp(scelta, "Ordine") == 0 || strcmp(scelta, "Ordine") == 0) {
    printf("Prodotto: ");
    fgets(reg.ordine.prodotto, sizeof(reg.ordine.prodotto), stdin);
    reg.ordine.prodotto[strcspn(reg.ordine.prodotto, "\n")] = 0;
    printf("Codice Identificativo: ");
    fgets(reg.ordine.codiceid, sizeof(reg.ordine.codiceid), stdin);
    reg.ordine.codiceid[strcspn(reg.ordine.codiceid, "\n")] = 0;
    printf("Prezzo: ");
    scanf("%lf", &reg.ordine.prezzo);
  } else {
    printf("Scelta non valita.\n");
  }

  printf("\nVariabili Inserite.\n");
  stampaOrdine(&reg);
}

This code mixes concepts of structs, unions, and user input to demonstrate data confusion due to the use of a union. Let’s break down what it does:

What the Code Does:

Struct Definitions for Cliente and Ordine:
- The Cliente structure represents a customer with attributes like nome (first name), cognome (last name), indirizzo (address), and eta (age).
- The Ordine structure represents an order with attributes like prodotto (product name), codiceid (identifier code), and prezzo (price).
Union Definition for Registro:
- The union Registro can hold either a Cliente or an Ordine. Only one of these structs can be stored at a time due to the nature of a union (shared memory).
Function stampaOrdine:
- The function accepts a pointer to a Registro union and treats the data within it as if it always contains an Ordine instance. It prints the fields prodotto, codiceid, and prezzo.
Main Function:
- The program prompts the user to specify whether they want to input Cliente (customer) or Ordine (order) data.
- Based on the user's choice:
  - If "Cliente" is chosen, it inputs the customer data and fills the client field of the union.
  - If "Ordine" is chosen, it inputs the order data and fills the ordine field of the union.
  - Any other choice generates an error message (“Scelta non valida.”).
- Finally, stampaOrdine is called, which attempts to interpret the union’s contents as if it holds an Ordine instance and prints those fields.

Behavior Analysis:

Use of a Union:
- A union allows memory sharing between its members (client and ordine in this case). This means the last-written data to the union will overwrite any existing data, and accessing the union as the wrong type leads to unpredictable results.
Type Confusion:
- No matter whether the user inputs a Cliente or Ordine, the stampaOrdine function always interprets the union as if it contains an Ordine. If the union actually held a Cliente, this would result in garbage output (because fields like prodotto and codiceid in the Ordine struct would fetch unrelated bytes from memory).

Input/Output Examples:

Example 1: Inputting a Customer (`Cliente`)

Input:

Vuoi aggiungere: Cliente o Ordine? 
Cliente
Nome: Mario
Cognome: Rossi
Indirizzo: Via Roma 10
Eta: 35

Output:

Variabili Inserite.
Prodotto: Mario
Codice Identificativo: Rossi
Prezzo: (garbage or undefined value)

Here, the Cliente data is misinterpreted as Ordine.

Example 2: Inputting an Order (`Ordine`)

Input:

Vuoi aggiungere: Cliente o Ordine? 
Ordine
Prodotto: Laptop
Codice Identificativo: 123456
Prezzo: 1200.50

Output:

Variabili Inserite.
Prodotto: Laptop
Codice Identificativo: 123456
Prezzo: 1200.50

This works correctly because stampaOrdine is designed to handle Ordine.

Key Takeaways:

Type Confusion:
- The Registro union can hold either Cliente or Ordine, but the program does not correctly handle cases where the wrong type is accessed, leading to undefined behavior.
Potential Bugs:
- If the user inputs a Cliente, the program incorrectly interprets the memory as an Ordine, leading to meaningless outputs when printing order details.
Improvement:
- To avoid such issues, the program should include a mechanism (e.g., a flag) to track the active type stored in the union and behave accordingly when accessing it.

In summary, this code highlights the dangers of using unions without proper type management, leading to data misinterpretation (type confusion).

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr