Creare un calcolatore console in C++

Il punto di partenza consueto per un programmatore C++ è un'applicazione "Hello, world!" eseguita nella riga di comando. Si inizierà con questo articolo e quindi si passerà a qualcosa di più complesso: un'app calcolatrice.

Prerequisiti

• Visual Studio con il carico di lavoro Sviluppo di applicazioni desktop con C++ installato e in esecuzione nel computer. Per installarlo, vedere Installare il supporto di C++ in Visual Studio.
• Questa esercitazione illustra una funzionalità denominata modifica e continuazione che consente di apportare modifiche al codice durante l'esecuzione dell'app. Per abilitare la modifica e continuare, dal menu principale selezionare Strumenti>Opzioni>Debug>generale e assicurarsi che Richiedi file di origine corrispondano esattamente alla versione originale.

Creare il progetto di app

Visual Studio usa progetti per organizzare il codice per un'app e soluzioni per organizzare uno o più progetti. Un progetto contiene tutte le opzioni, le configurazioni e le regole usate per compilare un'app. Gestisce anche la relazione tra tutti i file del progetto e i file esterni. Per creare prima di tutto l'app, creare un nuovo progetto e una nuova soluzione.

1. Avviare Visual Studio. Verrà visualizzata la finestra di dialogo Start di Visual Studio. Selezionare Crea un nuovo progetto per iniziare.

   

   La finestra di dialogo include opzioni per clonare un repository, aprire un progetto o una soluzione, aprire una cartella locale e creare un nuovo progetto."

2. Nell'elenco dei modelli di progetto selezionare App console, quindi selezionare Avanti.

   

   Importante

   Assicurarsi di selezionare la versione C++ del modello App console. La versione include i tag C++, Windows e Console e visualizza "++" nell'angolo dell'icona.

3. Nella finestra di dialogo Configura il nuovo progetto selezionare la casella di testo Nome progetto, denominare il nuovo progetto CalculatorTutorial e quindi selezionare Crea.

   

   Viene creata un'applicazione console Windows C++ vuota 'Hello World'. Le applicazioni console usano una finestra della console di Windows per visualizzare l'output e accettare l'input dell'utente. In Visual Studio si apre una finestra dell'editor e viene visualizzato il codice generato:

   // CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends there.
   //
   
   #include <iostream>
   
   int main()
   {
       std::cout << "Hello World!\n";
   }
   
   // Run program: Ctrl + F5 or Debug > Start Without Debugging menu
   // Debug program: F5 or Debug > Start Debugging menu
   
   // Tips for Getting Started:
   //   1. Use the Solution Explorer window to add/manage files
   //   2. Use the Team Explorer window to connect to source control
   //   3. Use the Output window to see build output and other messages
   //   4. Use the Error List window to view errors
   //   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
   //   6. In the future, to open this project again, go to File > Open > Project and select the .sln file
   

Verificare che la nuova app venga compilata ed eseguita

Il modello per una nuova applicazione console di Windows crea una semplice app "Hello World" di C++. A questo punto è possibile vedere in che modo Visual Studio compila ed esegue le app create direttamente dall'IDE.

1. Per compilare il progetto, selezionare Compila soluzione dal menu Compila . Nella finestra Output vengono visualizzati i risultati del processo di compilazione.

   

2. Per eseguire il codice, nella barra dei menu selezionare Debug, Avvia senza eseguire il debug (CTRL+F5).

   

   Si apre una finestra della console si apre e quindi viene eseguita l'app.

   Quando viene avviata in Visual Studio, un'app console esegue il codice, quindi stampa "Premere un tasto qualsiasi per chiudere questa finestra. . per dare la possibilità di vedere l'output.

   Complimenti. È stata creata la prima app console "Hello, world!" in Visual Studio.

3. Premere un tasto per chiudere la finestra della console e tornare a Visual Studio.

Ora sono disponibili gli strumenti necessari per compilare ed eseguire l'app dopo ogni modifica, per verificare che il codice continui a funzionare come previsto. In seguito viene illustrato come eseguirne il debug in caso contrario.

Modificare il codice

A questo punto, modificare il codice in questo modello in modo che sia un'app calcolatrice.

1. Sostituire il contenuto del CalculatorTutorial.cpp file con il codice seguente in modo che corrisponda a questo esempio:

   // CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends there.
   //
   
   #include <iostream>
   
   using namespace std;
   
   int main()
   {
       cout << "Calculator Console Application" << endl << endl;
       cout << "Please enter the operation to perform. Format: a+b | a-b | a*b | a/b"
           << endl;
       return 0;
   }
   
   // Run program: Ctrl + F5 or Debug > Start Without Debugging menu
   // Debug program: F5 or Debug > Start Debugging menu
   // Tips for Getting Started:
   //   1. Use the Solution Explorer window to add/manage files
   //   2. Use the Team Explorer window to connect to source control
   //   3. Use the Output window to see build output and other messages
   //   4. Use the Error List window to view errors
   //   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
   //   6. In the future, to open this project again, go to File > Open > Project and select the .sln file
   

   Informazioni sul codice:

   • Le istruzioni #include consentono di fare riferimento al codice che si trova in altri file. In alcuni casi viene visualizzato un nome file racchiuso tra parentesi quadre (<>), in altri casi il nome è racchiuso tra virgolette (" "). In generale, le parentesi quadre vengono usate quando si fa riferimento alla libreria standard C++, mentre le virgolette vengono usate per gli altri file.
   • La riga using namespace std; indica al compilatore che è previsto materiale in arrivo dalla libreria standard C++ da usare in questo file. Senza questa riga, ogni parola chiave della libreria deve essere preceduta da std:: per indicare il relativo ambito. Ad esempio, senza tale riga, ogni riferimento a cout deve essere scritto come std::cout. L'istruzione using viene aggiunta per rendere il codice più pulito.
   • La parola chiave cout viene usata per stampare in un output standard di C++. L'operatore << indica al compilatore di inviare tutto ciò che si trova alla sua destra all'output standard.
   • La endl parola chiave è simile alla chiave INVIO, termina la riga e sposta il cursore alla riga successiva. È consigliabile inserire una \n all'interno della stringa (contenuta da "") per eseguire la stessa operazione perché endl scarica sempre il buffer che può danneggiare le prestazioni del programma. Tuttavia, poiché si tratta di un'app molto piccola, endl viene usata invece per migliorare la leggibilità.
   • Tutte le istruzioni C++ devono terminare con un punto e virgola e tutte le applicazioni C++ devono contenere una funzione main(). Questa funzione è ciò che il programma esegue all'inizio. Tutto il codice deve essere accessibile da main() per poter essere usato.

2. Per salvare il file, premere CTRL+S oppure selezionare l'icona Salva nella parte superiore dell'IDE, l'icona del disco floppy sulla barra degli strumenti sotto la barra dei menu.

3. Per eseguire l'applicazione, premere CTRL+F5 o passare al menu Debug e selezionare Avvia senza eseguire debug. Dovrebbe essere visualizzata una finestra della console con il testo specificato nel codice.

4. Al termine, chiudere la finestra della console.

Aggiungere codice per eseguire alcuni calcoli matematici

Una classe è simile a un progetto per un oggetto che esegue un'operazione. In questo caso, si definisce una classe calcolatrice per contenere la logica matematica.

Aggiungere una classe Calculator

1. Passare al menu Progetto e selezionare Aggiungi classe. Nella casella di modifica Nome classe immettere Calculator. Seleziona OK.

   

   Il campo nome classe è impostato sul calcolatore. Il campo del file H contiene Calculator.h. Il campo del file di .cpp contiene Calculator.cpp. Il campo della classe di base è vuoto. Altre opzioni per il distruttore virtuale, inline e non gestito sono deselezionate.

   Due nuovi file vengono aggiunti al progetto. Per salvare tutti i file modificati in una sola volta, premere CTRL+MAIUSC+S. Si tratta di una scelta rapida da tastiera per File>Salva tutto. È anche disponibile un pulsante della barra degli strumenti per Salva tutto, un'icona con due dischi floppy, accanto al pulsante Salva. In generale, è buona norma scegliere spesso Salva tutto in modo da non tralasciare qualche file quando si salva.

   La procedura guidata Aggiungi classe crea .h e .cpp i file con lo stesso nome della classe. È possibile visualizzare un elenco completo dei file del progetto nella finestra Esplora soluzioni visibile sul lato dell'IDE. Se la finestra non è visibile, è possibile aprirla dalla barra dei menu: selezionare Visualizza> Esplora soluzioni.

   

   Il progetto dell'esercitazione del calcolatore include un nodo di file di intestazione contenente Calculator.h. Un nodo File di origine contiene Calculator.cpp e CalculatorTutorial.cpp. I nodi per riferimenti, dipendenze esterne e file di risorse sono visibili ma chiusi.

   È possibile aprire un file facendo doppio clic su di esso nella finestra Esplora soluzioni. Fare doppio clic Calculator.h per aprirlo.

2. Sostituire il contenuto di Calculator.h con il codice seguente in modo che il file sia ora simile al seguente:

   #pragma once
   class Calculator
   {
   public:
       double Calculate(double x, char oper, double y);
   };
   

   Informazioni sul codice

   • Questo codice dichiara una nuova funzione denominata Calculate, che viene usata per eseguire operazioni matematiche per addizione, sottrazione, moltiplicazione e divisione.
   • Il codice C++ è organizzato in file di intestazione (.h) e file di origine (.cpp). Diversi compilatori supportano alcune altre estensioni di file, ma queste sono le principali che è opportuno conoscere. Funzioni e variabili normalmente vengono dichiarate, con l'assegnazione di un nome e un tipo, nei file di intestazione e implementate, ovvero definite, nei file di origine. Per accedere al codice definito in un altro file, è possibile usare #include "filename.h", dove filename.h è il nome del file che dichiara le variabili o le funzioni da usare.
   • Può essere opportuno organizzare il codice in diversi file in base allo scopo, in modo che sia più facile trovare il codice necessario in un secondo tempo. In questo caso la classe Calculator viene definita separatamente dal file che contiene la funzione main(), ma si prevede di fare riferimento alla classe Calculator in main().

3. Viene visualizzata Calculate una sottolineatura a zigzag verde perché, sebbene la Calculate funzione sia dichiarata, non è definita. Passare il puntatore del mouse su Calculate, fare clic sulla freccia giù sul cacciavite visualizzato e selezionare Crea definizione di 'Calculate' in Calculator.cpp.

   

   Questo codice viene aggiunto a Calculator.cpp:

   

   La definizione del costruttore è: double Calculator::Calculate( double x, char oper, double y) { return 0.0; }

   Attualmente restituisce solo 0.0. Si può cambiare.

4. Passare al Calculator.cpp file nella finestra dell'editor. Sostituire il contenuto di Calculator::Calculate(double x, char oper, double y) con:

   double Calculator::Calculate(double x, char oper, double y)
   {
       switch(oper)
       {
           case '+':
               return x + y;
           case '-':
               return x - y;
           case '*':
               return x * y;
           case '/':
               return x / y;
           default:
               return 0.0;
       }
   }
   

   Informazioni sul codice

   • La funzione Calculate usa un numero, un operatore e un secondo numero, quindi esegue l'operazione richiesta sui numeri.
   • L'istruzione switch verifica quale operatore è stato specificato ed esegue solo il case corrispondente a tale operazione. Il case predefinito rappresenta il fallback nel caso in cui l'utente digiti un operatore che non viene accettato, in modo che il programma non venga interrotto. In generale, è consigliabile gestire l'input utente non valido in modo più elegante, ma ciò esula dall'ambito di questa esercitazione.
   • La parola chiave double denota un tipo di numero che supporta i decimali. In questo modo, la calcolatrice può gestire funzioni matematiche sia con numeri decimali che con numeri interi. La funzione Calculate è necessaria per restituire sempre un numero di questo tipo a causa della presenza di double all'inizio del codice (indica il tipo restituito della funzione), motivo per cui viene restituito 0.0 anche nel case predefinito.
   • Il .h file dichiara il prototipo di funzione, che indica al compilatore in anticipo quali parametri richiede e quale tipo restituito aspettarsi da esso. Il .cpp file include tutti i dettagli di implementazione della funzione.

Se si compila ed esegue di nuovo il codice a questo punto, verrà immediatamente chiuso dopo aver chiesto quale operazione eseguire. Modificare quindi la main funzione per eseguire più calcoli.

Chiamare le funzioni membro della Calculator classe

1. Aggiornare la main funzione in CalculatorTutorial.cpp come indicato di seguito:

   // CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends there.
   //
   
   #include <iostream>
   #include "Calculator.h"
   
   using namespace std;
   
   int main()
   {
       double x = 0.0;
       double y = 0.0;
       double result = 0.0;
       char oper = '+';
   
       cout << "Calculator Console Application" << endl << endl;
       cout << "Please enter the operation to perform. Format: a+b | a-b | a*b | a/b"
            << endl;
   
       Calculator c;
       while (true)
       {
           cin >> x >> oper >> y;
           result = c.Calculate(x, oper, y);
           cout << "Result " << "of " << x << oper << y << " is: " << result << endl;
       }
   
       return 0;
   }
   

   Informazioni sul codice

   • Poiché i programmi C++ iniziano sempre con la funzione main(), è necessario chiamare altro codice da tale posizione, quindi è necessaria un'istruzione #include.
   • Alcune variabili iniziali, x, y, oper e result, vengono dichiarate per archiviare rispettivamente il primo numero, il secondo numero, l'operatore e il risultato finale. È sempre consigliabile assegnare alcuni valori iniziali per evitare comportamenti non definiti, ovvero ciò che viene fatto qui.
   • La riga Calculator c; dichiara un oggetto denominato "c" come istanza della classe Calculator. La classe stessa è semplicemente un progetto iniziale per il funzionamento delle calcolatrici e l'oggetto è la calcolatrice specifica che esegue le funzioni matematiche.
   • L'istruzione while (true) è un ciclo. Il codice all'interno del ciclo continua a essere eseguito ripetutamente finché la condizione all'interno di () risulta vera. Poiché la condizione viene indicata semplicemente come true, è sempre vera, quindi il ciclo viene eseguito all'infinito. Per chiudere il programma, l'utente deve chiudere manualmente la finestra della console. In caso contrario, il programma attende sempre un nuovo input.
   • La parola chiave cin viene usata per accettare l'input da parte dell'utente. Questo flusso di input è in grado di elaborare una riga di testo immessa nella finestra della console e di inserirla all'interno di ogni variabile specificata, in ordine, presupponendo che l'input dell'utente corrisponda alla specifica richiesta. È possibile modificare questa riga in modo da accettare tipi diversi di input, ad esempio più di due numeri, anche se la Calculate() funzione deve essere aggiornata per gestirlo.
   • L'espressione c.Calculate(x, oper, y); chiama la funzione Calculate definita in precedenza e specifica i valori di input immessi. La funzione restituisce quindi un numero che viene memorizzato in result.
   • Infine, result viene stampato nella console, in modo che l'utente veda il risultato del calcolo.

Compilare e testare di nuovo il codice

Testare di nuovo il programma per assicurarsi che tutto funzioni correttamente.

1. Premere CTRL+F5 per ricompilare e avviare l'app.

2. Immettere 5+5 e premere INVIO. Verificare che il risultato sia 10.

   

   L'app restituisce il messaggio: immettere l'operazione da eseguire. Formato: a+b | a-b | a*b | a/b. L'utente ha immesso 5+5. L'output dell'app: risultato di 5+5 è: 10

Eseguire il debug dell'app

Poiché l'utente è libero di digitare qualsiasi elemento nella finestra della console, assicurarsi che il calcolatore gestisca l'input imprevisto. Invece di eseguire il programma, eseguiamo il debug in modo da poter esaminare le operazioni che esegue in modo dettagliato.

Eseguire l'app nel debugger

1. In CalcuatorTutorial.cppimpostare un punto di interruzione nella riga : result = c.Calculate(x, oper, y);. Per impostare il punto di interruzione, fare clic accanto alla riga nella barra grigia verticale lungo il bordo sinistro della finestra dell'editor. Viene visualizzato un punto rosso.

   

   Quando si esegue il debug del programma, l'esecuzione viene sospesa in corrispondenza di tale riga. È già appurato che il programma funziona nei casi semplici. Poiché non si vuole sospendere l'esecuzione ogni volta che si chiama Calculate(), si rende condizionale il punto di interruzione.

2. Fare clic con il pulsante destro del mouse sul punto rosso che rappresenta il punto di interruzione e selezionare Condizioni. Nella casella di modifica per la condizione immettere (y == 0) && (oper == '/'). Selezionare il pulsante Chiudi per salvare la condizione del punto di interruzione.

   

   La condizione per il punto di interruzione è: y==0 && oper == '/' è true.

   A questo punto, l'esecuzione verrà sospesa in corrispondenza del punto di interruzione quando l'app tenta di dividere per 0.

3. Per eseguire il debug del programma, premere F5 o selezionare il pulsante della barra degli strumenti Debugger windows locale con l'icona a forma di freccia verde. Nell'app console, se si immette un valore del tipo "5 - 0", il programma ha un comportamento normale e rimane in esecuzione. Tuttavia, se si digita "10 / 0", si interrompe in corrispondenza del punto di interruzione. È possibile inserire un numero qualsiasi di spazi tra l'operatore e i numeri: cin è abbastanza intelligente da analizzare l'input in modo appropriato.

   

Finestre utili nel debugger

Quando si esegue il debug del codice, è possibile notare che vengono visualizzate alcune nuove finestre. Queste finestre possono semplificare l'esperienza di debug. Osservare la finestra Auto. La finestra Auto contiene i valori correnti delle variabili usate almeno tre righe prima e fino alla riga corrente.

Il valore di oper è 47 '/', il risultato è 5, x è 10 e y è 0.

Per visualizzare tutte le variabili da tale funzione, passare alla finestra Variabili locali. È possibile modificare i valori di queste variabili durante il debug per vedere quale effetto avrebbe sul programma. In questo caso, li lasciamo soli.

Il valore di oper è 47 '/', il risultato è 0, x è 10 e y è 0.

È anche possibile passare il puntatore del mouse sulle variabili nel codice per visualizzare i valori correnti nel punto in cui l'esecuzione è attualmente sospesa. Verificare che la finestra dell'editor sia attiva facendo clic su di essa.

Continuare il debug

1. La freccia gialla a sinistra mostra il punto di esecuzione corrente. La riga corrente chiama Calculate, quindi premere F11 per selezionare Esegui istruzione per la funzione. A questo momento si sta eseguendo il codice nel corpo della Calculate funzione. Prestare attenzione a Esegui istruzione in perché esegue l'istruzione in tutte le funzioni nella riga in uso, incluse le funzioni della libreria standard. È consigliabile passare alla libreria standard, ma potrebbe essere più interessante concentrarsi sul codice anziché sul codice della libreria.

2. Ora che il punto di esecuzione è all'inizio della funzione Calculate, premere F10 per passare alla riga successiva nell'esecuzione del programma. La funzione F10 è anche nota come Esegui istruzione/routine. È possibile usare Passa per passare da una riga all'altra senza scendere nel dettaglio di ciò che avviene in ogni parte della riga. In generale, è consigliabile usare Step Over invece di Esegui istruzione in, a meno che non si voglia approfondire il codice che viene chiamato da un'altra posizione (come si è fatto per raggiungere il corpo di Calculate).

3. Continuare a usare F10 per passare ogni riga finché non si torna alla funzione main() nell'altro file e fermarsi alla riga cout.

   Il programma esegue ciò che è previsto: prende il primo numero e lo divide per il secondo. Sulla riga cout passare il mouse sulla variabile result o esaminare result nella finestra Auto. Il valore inf, che non ha un aspetto corretto, quindi è possibile correggerlo. La riga cout restituisce semplicemente qualsiasi valore archiviato in result, quindi se si va avanti di un'altra riga usando F10, la finestra della console visualizza:

   

   Output dell'app: immettere l'operazione da eseguire. Formato: a+b | a-b | a*b | a/b. L'utente ha immesso 5-0. L'output dell'app: risultato è: 5. L'utente ha immesso 10/0. L'output dell'app: Result is: inf

   Questo risultato è dovuto al fatto che la divisione per zero non è definita, quindi il programma non ha una risposta numerica per l'operazione richiesta.

Correggere l'errore di divisione per zero

Gestire la divisione per zero in modo più semplice in modo che sia più facile per l'utente comprendere il problema.

1. Modificare CalculatorTutorial.cpp nel modo seguente. È possibile lasciare il programma in esecuzione mentre si modifica, grazie a una funzionalità del debugger denominata Modifica e continuazione). Aggiungere un'istruzione if seguente cin >> x >> oper >> y; per verificare la presenza di divisione per zero e restituire un messaggio all'utente in caso affermativo. In caso contrario, il risultato viene stampato.

   // CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends there.
   //
   
   #include <iostream>
   #include "Calculator.h"
   
   using namespace std;
   
   int main()
   {
       double x = 0.0;
       double y = 0.0;
       double result = 0.0;
       char oper = '+';
   
       cout << "Calculator Console Application" << endl << endl;
       cout << "Please enter the operation to perform. Format: a+b | a-b | a*b | a/b" << endl;
   
       Calculator c;
       while (true)
       {
           cin >> x >> oper >> y;
           if (oper == '/' && y == 0)
           {
               cout << "Attempted to divide by zero!" << endl;
               continue;
           }
           else
           {
               result = c.Calculate(x, oper, y);
           }
           cout << "Result " << "of " << x << oper << y << " is: " << result << endl;
       }
   
       return 0;
   }
   

2. Premere F5 una sola volta. L'esecuzione del programma continua finché non deve essere sospesa per richiedere l'input dell'utente. Immettere di nuovo 10 / 0. A questo punto viene stampato un messaggio più utile. Viene chiesto all'utente di immettere altro input e il programma continua normalmente l'esecuzione.

   

   La finestra della console visualizza due righe: 10/ 0 Risultato è: inf, seguito da errore matematico 10/0: Tentativo di divisione per zero.

   Nota

   Quando si modifica il codice mentre si è in modalità di debug, è possibile che il codice risulti non aggiornato. Ciò si verifica quando il debugger sta ancora eseguendo il codice precedente e non lo ha ancora aggiornato con le modifiche. Il debugger visualizza una finestra di dialogo per informare l'utente quando si verifica questo problema. A volte può essere necessario premere F5 per aggiornare il codice in esecuzione. In particolare, se si apporta una modifica all'interno di una funzione mentre il punto di esecuzione si trova all'interno di tale funzione, è necessario uscire dalla funzione, quindi tornare indietro per ottenere il codice aggiornato. Se questo non funziona e viene visualizzato un messaggio di errore, è possibile arrestare il debug facendo clic sul quadrato rosso nella barra degli strumenti sotto i menu nella parte superiore dell'IDE, quindi avviare di nuovo il debug immettendo F5 o scegliendo la freccia verde "play" accanto al pulsante di arresto sulla barra degli strumenti.

   Un altro motivo per cui la modifica e la continuazione potrebbero non riuscire è se viene visualizzato un messaggio che indica che è necessario abilitare il messaggio "Richiedi file di origine per corrispondere esattamente all'impostazione della versione originale in Debug-Options-General>>..." Per risolvere il problema, dal menu principale selezionare Strumenti>Opzioni>debug>Generale e assicurarsi che Richiedi file di origine corrispondano esattamente alla versione originale.

   Informazioni sui tasti di scelta rapida di esecuzione e debug

   • F5 (o Debug>Avvia debug) avvia una sessione di debug, se non ne è stata già attivata una, ed esegue il programma finché non viene raggiunto un punto di interruzione o il programma richiede l'input dell'utente. Se non è necessario alcun input dell'utente e non è disponibile un punto di interruzione da raggiungere, il programma termina e la finestra della console si chiude quando il programma completa l'esecuzione. Se si dispone di un programma simile a "Hello World" da eseguire, usare CTRL+F5 o impostare un punto di interruzione prima di premere F5 per mantenere aperta la finestra.
   • CTRL+F5 (o Debug>Avvia senza eseguire debug) consente di eseguire l'applicazione senza entrare nella modalità di debug. L'operazione è leggermente più veloce rispetto al debug e la finestra della console rimane aperta dopo che il programma termina l'esecuzione.
   • F10 (opzione Passa) consente di scorrere il codice riga per riga e di vedere in che modo viene eseguito il codice e quali sono i valori delle variabili in ogni fase dell'esecuzione.
   • F11 (opzione Esegui istruzione) funziona in modo analogo a Passa, ad eccezione del fatto che esegue le istruzioni per tutte le funzioni chiamate sulla riga di esecuzione. Ad esempio, se la riga da eseguire chiama una funzione, premendo F11 il puntatore del mouse si sposta nel corpo della funzione, quindi è possibile seguire il codice della funzione da eseguire prima di tornare alla riga da cui si è partiti. Premendo F10 si passa semplicemente alla riga successiva ignorando la chiamata alla funzione, che avviene ugualmente, ma il programma non si interrompe per indicare quale operazione sta eseguendo.

Chiudere l'app

• Se è ancora in esecuzione, chiudere la finestra della console per l'app calcolatrice.

Aggiungere il controllo del codice sorgente Git

Dopo aver creato un'app, è possibile aggiungerla a un repository Git. Nessun problema. Visual Studio semplifica questo processo con gli strumenti Git che è possibile usare direttamente dall'IDE.

Suggerimento

Git è il sistema di controllo della versione più diffuso, quindi se si è uno sviluppatore professionista o si sta imparando a scrivere codice, Git può essere molto utile. Se non si ha familiarità con Git, il https://git-scm.com/ sito Web è un buon punto di partenza. Qui è possibile trovare fogli di trucco, un libro online popolare e video di Base su Git.

Per associare il codice a Git, iniziare creando un nuovo repository Git in cui si trova il codice. In tal caso, eseguire la procedura seguente:

1. Nella barra di stato nell'angolo inferiore destro di Visual Studio selezionare Aggiungi al controllo del codice sorgente e quindi selezionare Git.

   

2. Nella finestra di dialogo Crea un repository Git accedere a GitHub.

   

   Il nome del repository viene popolato automaticamente in base al percorso della cartella. Per impostazione predefinita, il nuovo repository è privato, ovvero l'unico che può accedervi.

   Suggerimento

   Indipendentemente dal fatto che il repository sia pubblico o privato, è consigliabile disporre di un backup remoto del codice archiviato in modo sicuro in GitHub. Anche se non si lavora con un team, un repository remoto rende disponibile il codice da qualsiasi computer.

3. Selezionare Crea ed esegui push.

   Dopo aver creato il repository, i dettagli sullo stato vengono visualizzati nella barra di stato.

   

   La prima icona con le frecce mostra il numero di commit in uscita/in ingresso nel ramo corrente. È possibile usare questa icona per eseguire il pull di tutti i commit in ingresso o eseguire il push di tutti i commit in uscita. È anche possibile scegliere di visualizzare prima questi commit. A tale scopo, selezionare l'icona e quindi selezionare Visualizza in uscita/In ingresso.

   La seconda icona con la matita mostra il numero di modifiche di cui non è stato eseguito il commit nel codice. È possibile selezionare questa icona per visualizzare le modifiche nella finestra Modifiche Git.

Per altre informazioni su come usare Git con l'app, vedere la documentazione sul controllo della versione di Visual Studio.

L'app completata

Complimenti. È stato completato il codice per l'app calcolatrice, è stato compilato e sottoposto a debug e aggiunto a un repository, tutto in Visual Studio.

Passaggi successivi

Altre informazioni su Visual Studio per C++