This code is a C program that demonstrates the use...

August 26, 2025 at 05:12 PM

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

// Struct Client
typedef struct {
  char nome[20];
  char cognome[20];
  char email[20];
  int puntiFedelta;
} Cliente;

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

// Unione di CLient e Ordine
union Registro {
  Cliente client;
  Ordine ordine;
};

// Metodo con type confusion tratto tutti i dati del Registro 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;
  
  // 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("E-mail: ");
    fgets(reg.client.email, sizeof(reg.client.email), stdin);
    reg.client.email[strcspn(reg.client.email, "\n")] = 0;
    printf("Punti Fedelta: ");
    scanf("%d", &reg.client.puntiFedelta);
    
  } 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");
    
  }
  
  
  // Stampo le variabili inserite
  printf("\nVariabili Inserite.\n");
  stampaOrdine(&reg);
}

This code is a C program that demonstrates the use of a union to combine two different data structures (Cliente and Ordine) into a single variable type (Registro). However, it contains a fundamental flaw related to "type confusion." Here's a detailed explanation of what the code does:

1. Struct Definitions

The code defines two structs:
- Cliente: Contains details about a client (nome, cognome, email, and an integer puntiFedelta).
- Ordine: Contains details about an order (prodotto, codiceid, and a prezzo of type double).

2. Union Definition

The union Registro can hold either:
- A Cliente struct.
- Or an Ordine struct.
A union in C shares memory for all its members, meaning that the memory for Registro will overlap regardless of whether you treat it as a Cliente or Ordine.

3. `stampaOrdine` Function

The function stampaOrdine takes a pointer to the union Registro and treats the memory as if it represents an Ordine.
It prints the values of the fields from the memory assuming it's an Ordine, without concerning itself with whether the memory actually holds a valid instance of an Ordine.

4. Main Function Logic

The user is prompted to choose between entering details for a Cliente or an Ordine.
- Depending on the input, the fields of the corresponding struct in the union are populated.
- If the user enters "Cliente", the Cliente fields in the union are filled.
- If the user enters "Ordine", the Ordine fields in the union are filled.
Regardless of the user's input, the program calls stampaOrdine to print the memory as if it were an Ordine. This introduces type confusion since:
- If the union was populated with a Cliente, the program still interprets it as an Ordine, potentially printing garbage values or incorrect data.
- If the union truly contains an Ordine, it will print the correct order details.

5. Issues in the Code

Type Confusion: The program always assumes the union contains an Ordine when calling stampaOrdine, regardless of whether the union actually contains a Cliente or Ordine.
- For example, if the user enters data for a Cliente, calling stampaOrdine will interpret the Cliente data as an Ordine and print nonsensical output.
Logical Error when Checking Input: In the second branch of the if-else statement, the condition strcmp(scelta, "Ordine") == 0 || strcmp(scelta, "Ordine") == 0 redundantly checks the same condition twice instead of possibly checking for variations (e.g., lowercase "ordine").
Unused Input Sanitization: If invalid input is supplied, the program just prints "Scelta non valida." and does not handle this further.
No Memory Safety: There is no mechanism to ensure that string inputs from fgets do not exceed the allocated storage in the char arrays.

Example Behavior

Case 1: If the user chooses "Cliente":

Vuoi aggiungere: Cliente o Ordine? 
Cliente
Nome: John
Cognome: Doe
E-mail: john.doe@example.com
Punti Fedelta: 100

Variabili Inserite.
Prodotto: John
Codice Identificativo: Doe 
Prezzo: 0.00

Here, the Cliente data is misinterpreted as an Ordine, resulting in nonsense output.

Case 2: If the user chooses "Ordine":

Vuoi aggiungere: Cliente o Ordine? 
Ordine
Prodotto: Laptop
Codice Identificativo: ABC123
Prezzo: 1499.99

Variabili Inserite.
Prodotto: Laptop
Codice Identificativo: ABC123 
Prezzo: 1499.99

Here, the program correctly processes the input since the union was populated with an Ordine.

Summary

The code demonstrates the dangers of type confusion when using unions without proper checks. The stampaOrdine function blindly interprets the union's memory as an Ordine, which will fail if the union actually holds a Cliente. To make the program safe, the union should include a tag (e.g., an enumeration) to explicitly track what data type (Cliente or Ordine) is currently stored in the union.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr