Scrivere Compilare Ed Eseguire Il Primo Programma

Apri un progetto Console application del linguaggio scelto. Se utilizzi il pacchetto scaricabile, estrailo e apri il CBP contenuto nella cartella dell’esempio. Controlla il compilatore del progetto: i CBP forniti selezionano GNU GCC Compiler, quindi su un percorso Clang devi scegliere una configurazione compatibile nelle impostazioni del progetto.

Prima dell’avvio controlla tre elementi: progetto attivo, target Debug e sorgente corretto. La cartella dell’esempio contiene un solo main. Non aggiungere al medesimo progetto i sorgenti di tutti gli esempi: sono programmi indipendenti.

Schema esplicativo originale creato per il capitolo.

I sorgenti degli esempi sono portabili per il percorso console descritto, ma la toolchain deve essere preparata sul computer. Il pacchetto non contiene compilatori né eseguibili precompilati per tutti i sistemi.

Torna all’indice della pagina

Apri main.c nel progetto PrimoC. Il programma usa la libreria standard per stampare un saluto e il totale di tre articoli da dodici euro.

#include <stdio.h>

int main(void) {
    const int prezzo = 12;
    const int quantita = 3;
    const int totale = prezzo * quantita;

    printf("Ciao da C!\n");
    printf("Totale: %d euro\n", totale);
    return 0;
}

#include <stdio.h> rende disponibili le dichiarazioni delle funzioni di input/output utilizzate. main è il punto d’ingresso di questo programma. Le variabili intere rappresentano prezzo, quantità e risultato; const esprime che non vengono modificate dopo l’inizializzazione.

printf stampa testo formattato. %d è il segnaposto per il valore intero fornito come argomento. \n aggiunge un ritorno a capo. Il valore restituito da main comunica l’esito al sistema: qui zero indica il completamento riuscito.

L’esempio usa valori interi per concentrarsi sulla sequenza dell’IDE. Non è una soluzione generale per il calcolo di denaro, arrotondamenti o quantità frazionarie.

Torna all’indice della pagina

1. Salva main.c con File → Save.
2. Controlla che PrimoC sia il progetto attivo e che il target sia Debug.
3. Scegli Build → Build and run.
4. Leggi Build log: la compilazione e il collegamento devono terminare senza errori.
5. Attendi la console e leggi le righe prodotte dal programma.

Ciao da C!
Totale: 36 euro

Il console runner può aggiungere righe sull’esito del processo e attendere un tasto. Queste righe non devono essere copiate nel sorgente. Se la build si interrompe, correggi il problema prima di attribuire un vecchio output al nuovo programma.

Schema esplicativo originale creato per il capitolo.

Dopo una modifica salva e ripeti Build and run. Il programma già costruito non cambia mentre modifichi il sorgente. L’IDE deve generare la nuova versione per far apparire il nuovo comportamento.

Torna all’indice della pagina

Apri il progetto PrimoCPP e il suo main.cpp. La struttura è simile nell’obiettivo, ma utilizza lo stream di output della libreria C++.

#include <iostream>

int main() {
    const int prezzo = 12;
    const int quantita = 3;
    const int totale = prezzo * quantita;

    std::cout << "Ciao da C++!\n";
    std::cout << "Totale: " << totale << " euro\n";
    return 0;
}

<iostream> dichiara le funzionalità degli stream. std::cout è lo stream di output standard; l’operatore << invia valori e testo verso lo stream. std:: qualifica i nomi nello spazio dei nomi della libreria standard.

Salva e usa Build and run. Il risultato previsto è Ciao da C++! seguito da Totale: 36 euro. Per questo progetto serve il percorso C++ della toolchain, compresa la relativa libreria standard in fase di collegamento.

Non introdurre using namespace std; soltanto per correggere un errore che riguarda l’assenza del compilatore o delle librerie. Il sorgente mostrato usa esplicitamente i nomi qualificati e consente di distinguere i componenti del linguaggio dagli strumenti.

Torna all’indice della pagina

Il progetto QuantitaC aggiunge un dato da tastiera. Il prezzo rimane fisso e la quantità viene letta durante l’esecuzione. Questo rende evidente dove digitare un input.

#include <stdio.h>

int main(void) {
    const int prezzo = 12;
    int quantita = 0;

    printf("Inserisci una quantita intera tra 1 e 100: ");
    fflush(stdout);
    if (scanf("%d", &quantita) != 1) {
        fprintf(stderr, "Dato non valido.\n");
        return 1;
    }
    if (quantita < 1 || quantita > 100) {
        fprintf(stderr, "Quantita fuori intervallo.\n");
        return 1;
    }

    printf("Totale: %d euro\n", prezzo * quantita);
    return 0;
}

Quando compare la richiesta, fai clic nella console del programma, digita 3 e premi Invio. Il risultato sarà Totale: 36 euro. Il valore non va inserito in Build log o nell’editor.

fflush(stdout) rende esplicita l’emissione della richiesta prima della lettura, che non è preceduta da un ritorno a capo. scanf riceve l’indirizzo della variabile attraverso &quantita; il valore restituito indica se è stata effettuata la conversione prevista. Il limite da 1 a 100 evita valori fuori dal dominio dell’esempio.

Questo controllo è sufficiente per illustrare la lettura di un normale intero nel percorso introduttivo; non è un parser generale per qualsiasi stringa o numero arbitrariamente grande. I capitoli sul linguaggio potranno approfondire la gestione completa di righe di input.

Torna all’indice della pagina

Il progetto QuantitaCPP realizza lo stesso percorso con gli stream C++.

#include <iostream>

int main() {
    const int prezzo = 12;
    int quantita = 0;

    std::cout << "Inserisci una quantita intera tra 1 e 100: ";
    if (!(std::cin >> quantita)) {
        std::cerr << "Dato non valido.\n";
        return 1;
    }
    if (quantita < 1 || quantita > 100) {
        std::cerr << "Quantita fuori intervallo.\n";
        return 1;
    }

    std::cout << "Totale: " << prezzo * quantita << " euro\n";
    return 0;
}

std::cin >> quantita tenta di leggere un intero. Il controllo dello stato permette di gestire un fallimento della lettura; std::cerr ospita il messaggio di errore. Anche qui il programma termina con un valore non zero quando l’input non è utilizzabile per il calcolo.

Il programma può restare in attesa finché non confermi il dato con Invio. Se hai più finestre aperte, seleziona quella dell’esecuzione corrente. Il testo già presente nella console può appartenere a una precedente esecuzione: chiudi le sessioni concluse quando non servono più.

Torna all’indice della pagina

Il percorso dell’output dipende dalle impostazioni del target. Nei progetti scaricabili è previsto sotto bin/Debug o bin/Release. Il sorgente resta nella cartella del progetto; gli oggetti intermedi sono sotto obj.

Non distribuire soltanto il CBP pensando che contenga il programma finito: è un file di progetto. Non distribuire un eseguibile Windows come se fosse portabile su Linux o macOS. Il sorgente portabile viene compilato con la toolchain destinata al sistema.

Torna all’indice della pagina

Il ciclo normale è modificare → salvare → costruire → avviare → osservare. Quando la build fallisce il percorso si ferma prima del nuovo eseguibile. Quando il programma aspetta un input, il percorso è già arrivato all’esecuzione.

Cambiare il target Debug/Release cambia la configurazione di output. Controlla il target se il risultato sembra non aggiornarsi. Usa Rebuild quando devi ricostruire consapevolmente il target, non come sostituto della lettura dell’errore.

I quattro progetti del pacchetto sono separati: PrimoC, PrimoCPP, QuantitaC e QuantitaCPP. Per aprirne uno, estrai il pacchetto e apri il relativo CBP. Il file LEGGIMI degli esempi descrive come scegliere la toolchain sulla piattaforma effettiva.

Torna all’indice della pagina