Mettere tutto insieme

Fa parte della sezione Logica e flusso del percorso C di Coddy. Lezione 54 di 63.

Sfida

Facile

Completa il tuo sistema di gestione dei contatti integrando tutte le funzioni che hai creato nelle lezioni precedenti. Il tuo programma dovrebbe:

Usare la stessa definizione della struct Contact delle lezioni precedenti, con i membri:
- Un array di caratteri name di dimensione 50
- Un array di caratteri phone di dimensione 20
- Un array di caratteri email di dimensione 40
- Un intero age
Usare la stessa funzione createContact delle lezioni precedenti, che:
- Alloca dinamicamente memoria per una struct Contact
- Inizializza tutti i membri con valori predefiniti
- Restituisce un puntatore al contatto
Usare la stessa funzione populateContact delle lezioni precedenti, che:
- Riceve come parametro un puntatore a una struct Contact
- Richiede l'input dell'utente e popola tutti i campi del contatto
- Convalida i dati inseriti
Scrivere una funzione displayContact che:
- Riceve come parametro un puntatore costante a una struct Contact
- Stampa ogni campo su una riga separata, nel seguente formato esatto:
  Name: John
  Phone: 555-1234
  Email: john@email.com
  Age: 25
Scrivere una funzione chiamata updateContact che:
- Riceve come parametro un puntatore a una struct Contact
- Non restituisce nulla (void)
- Chiede all'utente quale campo aggiornare, stampando:
  - What would you like to update?
  - 1. Name
  - 2. Phone
  - 3. Email
  - 4. Age
  - Enter choice (1-4):
- Legge la scelta dell'utente e aggiorna il campo corrispondente:
  - Se la scelta è 1: stampa Enter new name: e aggiorna il nome
  - Se la scelta è 2: stampa Enter new phone: e aggiorna il telefono
  - Se la scelta è 3: stampa Enter new email: e aggiorna l'email
  - Se la scelta è 4: stampa Enter new age: e aggiorna l'età
  - Se la scelta non è valida (non è compresa tra 1 e 4): stampa Invalid choice
- Dopo un aggiornamento riuscito, stampa Contact updated successfully
Nella funzione principale, implementare un flusso di lavoro completo per la gestione dei contatti:
- Creare un contatto usando la funzione createContact
- Verificare che la creazione del contatto sia riuscita
- Chiamare la funzione populateContact per inserire i dati iniziali del contatto
- Stampare --- Initial Contact ---
- Chiamare la funzione displayContact per mostrare le informazioni iniziali del contatto
- Stampare --- Updating Contact ---
- Chiamare la funzione updateContact per modificare un campo
- Stampare --- Updated Contact ---
- Chiamare nuovamente la funzione displayContact per mostrare le informazioni aggiornate del contatto
- Liberare la memoria allocata dinamicamente
- Stampare Contact management completed

Nota: La funzione displayContact di questa lezione usa un formato semplice: una riga per campo, senza dettagli o unità aggiuntivi (ad es., l'età viene stampata come semplice numero, non come "25 years old"). Assicurati che l'output corrisponda esattamente al formato mostrato sopra, poiché i casi di test dipendono da questo.

Questa sfida finale riunisce tutti i componenti del tuo sistema di gestione dei contatti: definizione della struct, allocazione dinamica della memoria, inserimento e convalida dei dati, visualizzazione formattata e modifica dei dati. Dimostrerai il ciclo di vita completo di una struct allocata dinamicamente, dalla creazione alla pulizia, esercitandoti nell'organizzazione delle funzioni e nell'uso corretto dei puntatori durante l'intero processo.

Provalo tu

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

struct Contact {
    char name[50];
    char phone[20];
    char email[40];
    int age;
};

struct Contact* createContact() {
    struct Contact* contact = (struct Contact*)malloc(sizeof(struct Contact));
    if (contact != NULL) {
        strcpy(contact->name, "");
        strcpy(contact->phone, "");
        strcpy(contact->email, "");
        contact->age = 0;
    }
    return contact;
}

void populateContact(struct Contact* contactPtr) {
    printf("Enter name: ");
    fgets(contactPtr->name, sizeof(contactPtr->name), stdin);
    contactPtr->name[strcspn(contactPtr->name, "\n")] = '\0';
    
    printf("Enter phone: ");
    fgets(contactPtr->phone, sizeof(contactPtr->phone), stdin);
    contactPtr->phone[strcspn(contactPtr->phone, "\n")] = '\0';
    
    printf("Enter email: ");
    fgets(contactPtr->email, sizeof(contactPtr->email), stdin);
    contactPtr->email[strcspn(contactPtr->email, "\n")] = '\0';
    
    printf("Enter age: ");
    scanf("%d", &contactPtr->age);
}

void displayContact(const struct Contact *contactPtr) {
    printf("=== CONTACT DETAILS ===\n");
    printf("Name: %s\n", contactPtr->name);
    printf("Phone: %s\n", contactPtr->phone);
    printf("Email: %s\n", contactPtr->email);
    printf("Age: %d years old\n", contactPtr->age);
    printf("========================\n");
    
    printf("Name length: %lu characters\n", strlen(contactPtr->name));
    
    if (contactPtr->age >= 0 && contactPtr->age <= 12) {
        printf("Generation: Child\n");
    } else if (contactPtr->age >= 13 && contactPtr->age <= 19) {
        printf("Generation: Teenager\n");
    } else if (contactPtr->age >= 20 && contactPtr->age <= 39) {
        printf("Generation: Young Adult\n");
    } else if (contactPtr->age >= 40 && contactPtr->age <= 59) {
        printf("Generation: Middle-aged Adult\n");
    } else if (contactPtr->age >= 60) {
        printf("Generation: Senior\n");
    }
    
    if (strchr(contactPtr->email, '@') != NULL) {
        printf("Email format: Valid\n");
    } else {
        printf("Email format: Invalid\n");
    }
}

int main() {
    struct Contact* contact = createContact();
    
    if (contact != NULL) {
        populateContact(contact);
        displayContact(contact);
        free(contact);
        printf("Program completed successfully\n");
    }
    
    return 0;
}

Tutte le lezioni di Logica e flusso

3Array di caratteri e stringhe

Stringhe come array di char Il terminatore null Input di stringhe con scanf Uso di strlen()Uso di strcpy()Uso di strcat()Uso di strcmp()Riepilogo: funzioni di base per le stringhe

6Gestione della memoria

Memoria Stack vs. Heap Allocazione dinamica - malloc()Usare sizeof() per l'allocazione Verificare il fallimento dell'allocazione Liberare la memoria con free()Allocare con calloc()Riepilogo: array dinamico

9Progetto: Inserimento semplice di un contatto

Progetto: Definire una struct Contatto Funzione per creare un contatto

Funzione per compilare un contatto

Funzione per visualizzare un contatto

Mettere tutto insieme Lezione di progetto

Esercitati da solo: Compilatore C online