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 inizia con questo articolo e quindi si passa 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 dell'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 tutti 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. Nella finestra di dialogo Crea un nuovo progetto impostare l'elenco a discesa linguaggio su C++, impostare l'elenco a discesa della piattaforma su Windows, selezionare App console dall'elenco dei tipi di progetto e quindi selezionare Avanti.

   

   L'elenco a discesa del linguaggio è impostato su C++, l'elenco a discesa della piattaforma è impostato su Windows e i tipi di progetto come Progetto vuoto, App console, Progetto CMake, Creazione guidata desktop di Windows e così via, vengono visualizzati nell'elenco dei tipi di progetto".

   Importante

   Assicurarsi di selezionare la versione C++ del modello App console . Include i tag C++, Windows e Console e l'icona ha "++" nell'angolo.

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 viene aperta 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 C++ "Hello World". A questo punto, è possibile vedere come Visual Studio compila ed esegue le app create direttamente dall'IDE.

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

   

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

   

   Viene visualizzata una finestra della console e l'app viene eseguita al suo interno.

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

   Congratulazioni! È 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.

Sono ora disponibili gli strumenti per compilare ed eseguire l'app dopo ogni modifica, per verificare che il codice funzioni ancora 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:

   • L'istruzione #include inserisce il codice in altri file. In alcuni casi, è possibile che venga visualizzato un nome di file racchiuso tra parentesi angolari come <iostream>. Le parentesi angolari indicano al compilatore di cercare prima il iostream file di intestazione nelle directory di sistema standard e, se non viene trovato, di cercare nelle directory specifiche del progetto. In altri casi, è possibile che venga visualizzato un nome di file racchiuso tra virgolette come "someHeader.h". Le virgolette indicano al compilatore di ignorare la ricerca nelle directory di sistema standard e cercare solo nelle directory specifiche del progetto.
   • using namespace std; indica al compilatore di aspettarsi che il codice della libreria standard C++ venga usato 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 verrebbe scritto come std::cout. L'istruzione using viene aggiunta per rendere più conveniente l'accesso al codice in un altro namespace.
   • La cout parola chiave viene usata per stampare nell'output standard in C++. L'operatore << indica al compilatore di inviare qualsiasi elemento a destra dell'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 invece usata.
   • Tutte le istruzioni C++ devono terminare con punti e virgola e tutte le applicazioni C++ devono contenere una main() funzione. Questa funzione è quella che il programma esegue all'avvio. Per poter essere usato, è necessario che tutto il codice sia accessibile da main() .

2. Per salvare il file, premere CTRL+S oppure selezionare 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. Verrà visualizzata una finestra della console simile alla seguente.

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 Calcolatrice. Seleziona OK.

   

   Il campo nome classe contiene il calcolatore di testo. Il campo del file H contiene Calculator.h. Il campo del file di .cpp contiene Calculator.cpp. Il campo della classe di base è vuoto. Le opzioni per inline e Managed sono deselezionate.

   Due nuovi file vengono aggiunti al progetto. Per salvare tutti i file modificati contemporaneamente, premere CTRL+MAIUSC+S. Si tratta di un tasto di scelta rapida per File>Salva tutto. C'è anche un pulsante della barra degli strumenti per Salva tutto, un'icona di due dischi floppy, trovato accanto al pulsante Salva . In generale, è consigliabile fare spesso salva tutto , in modo da non perdere il salvataggio delle modifiche.

   La procedura guidata Aggiungi classe crea .h e .cpp i file con lo stesso nome della classe. È possibile visualizzare un elenco completo dei file di progetto nella finestra Esplora soluzioni , visibile sul lato dell'IDE. Se la finestra non è visibile, aprirla dalla barra dei menu tramite 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 gestisce operazioni matematiche per addizione, sottrazione, moltiplicazione e divisione.
   • Il codice C++ è organizzato in file di intestazione (.h) e file di origine (.cpp). Alcune altre estensioni di file sono supportate da vari compilatori, ma queste sono le principali da conoscere. Le funzioni e le variabili vengono in genere dichiarate, ovvero in base a un nome e a un tipo, nei file di intestazione e implementate o specificate una definizione, 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.
   • È consigliabile organizzare il codice in file diversi in base alle operazioni eseguite, quindi è facile trovare il codice necessario in un secondo momento. In questo caso, si definisce la Calculator classe separatamente dal file contenente la main() funzione , ma si prevede di fare riferimento alla Calculator classe 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ù sull'icona del cacciavite e selezionare Crea definizione di 'Calculate' in Calculator.cpp.

   

   Questo codice viene aggiunto a Calculator.cpp:

   

   La definizione della funzione è: 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 accetta un numero, un operatore e un secondo numero. Esegue quindi l'operazione richiesta sui due numeri.
   • L'istruzione switch controlla quale operatore è stato specificato ed esegue il caso corrispondente a tale operazione. Il default: caso è un fallback nel caso in cui l'utente digita un operatore che non viene gestito da alcuna istruzione precedente case . È consigliabile gestire l'input utente non valido in modo più elegante, ma questo non rientra nell'ambito di questa esercitazione.
   • La double parola chiave indica un tipo di numero che supporta i decimali. Questo tipo di numero viene chiamato numero a virgola mobile e double indica un numero a virgola mobile con precisione aggiuntiva. In questo modo, il calcolatore può gestire sia la matematica decimale che la matematica integer. La Calculate funzione è necessaria per restituire sempre un numero a virgola mobile a precisione doppia a causa dell'inizio double del codice (indica il tipo restituito della funzione), motivo per cui viene restituito 0,0 nel caso 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, viene 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 alla main() funzione, è necessario chiamare l'altro codice da questa posizione, quindi è necessaria un'istruzione #include per rendere visibile tale codice alla main() funzione.
   • Le variabili x, yoper, , 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 Calculator c; riga dichiara un oggetto denominato c come istanza della Calculator classe . La classe stessa è solo un progetto per il funzionamento delle calcolatrici; l'oggetto è il calcolatore specifico che esegue la matematica.
   • L'istruzione while (true) è un ciclo. Il codice all'interno del ciclo viene eseguito più volte fino a quando la condizione all'interno di () contiene true. Poiché la condizione è semplicemente elencata come true, è sempre true, quindi il ciclo viene eseguito per sempre. Per chiudere il programma, l'utente deve chiudere manualmente la finestra della console. In caso contrario, il programma attende sempre il nuovo input.
   • La cin parola chiave accetta input dall'utente. Il flusso di input è abbastanza intelligente da elaborare una riga di testo immessa nella finestra della console e inserirla all'interno di ognuna delle variabili elencate, in ordine.
   • L'espressione c.Calculate(x, oper, y); chiama la Calculate funzione definita in precedenza e fornisce i valori di input immessi e l'operazione richiesta. La funzione restituisce quindi un numero archiviato in result.
   • Infine, result viene stampato nella console e l'utente visualizza 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+5e 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

3. Arrestare il programma chiudendo la finestra della console.

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 verticale grigia lungo il bordo sinistro della finestra dell'editor in modo che venga visualizzato un punto rosso.

   

   Quando si esegue il debug del programma, l'esecuzione viene sospesa in corrispondenza di tale riga. Abbiamo già un'idea approssimativa che il programma funziona per semplici casi. 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.

   

   Il punto di interruzione si trova nella riga: result = c dot Calculate ( x, oper, y). 'Condizioni...' L'opzione Condizione è selezionata. L'elenco a discesa "Condizioni" è impostato su "Espressione condizionale". L'elenco a discesa delle condizioni è impostato su "È vero". La condizione è impostata su y == 0 && oper == '/'.

   Ora, l'esecuzione viene 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 qualcosa come "5 - 0", il programma si comporta normalmente e continua a essere in esecuzione. Tuttavia, se si digita "10 / 0", l'esecuzione si arresta al 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 essere utili per l'esperienza di debug. Dai un'occhiata alla finestra Auto. La finestra Auto mostra i valori correnti delle variabili usate almeno tre righe prima e fino alla riga corrente. Se non viene visualizzata la finestra Auto, dal menu principale selezionare Debug>di Windows>Auto.

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

Per visualizzare tutte le variabili di tale funzione, passare alla finestra Variabili locali . Poiché si tratta di una piccola funzione, la finestra Auto e Variabili locali mostra le stesse variabili. Tuttavia, è possibile modificare i valori di queste variabili nella finestra Variabili locali durante il debug per vedere quale effetto avrebbe sul programma. In questo caso, li lasciamo soli. Aprire la finestra Variabili locali selezionando Variabili locali nella parte inferiore della finestra Auto oppure selezionando dal menu principale Debug>variabili locali>.

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. Assicurarsi che la finestra dell'editor sia attiva facendo clic prima 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 passare alla funzione . A questo momento si sta eseguendo il codice nel corpo della Calculate funzione. Prestare attenzione a Passo dentro perché esegue un passo dentro qualsiasi funzione sulla riga corrente, 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 Calculate funzione, premere F10 per passare alla riga successiva nell'esecuzione del programma. F10 è noto anche come Step Over. È possibile usare Step Over per spostarsi da riga a riga, senza approfondire i dettagli di ciò che si sta verificando in ogni parte della riga. In generale, è consigliabile usare Step Over invece di Step Into, a meno che non si voglia approfondire il codice che viene chiamato da un'altra parte (come fatto per raggiungere il corpo di Calculate).

3. Continuare a usare F10 per eseguire il passaggio su ogni riga finché non si torna alla main() funzione nell'altro file e si arresta sulla cout riga.

   Il programma esegue ciò che è previsto: prende il primo numero e lo divide per il secondo. Sulla cout riga, passa il puntatore del mouse sulla variabile result o osserva result nella finestra Autos. Il valore è inf, che non sembra corretto.

   

   L'istruzione corrente nel debugger è cout << "Result is: " << risultato << endl; Nella finestra auto il risultato è inf.

   Risolviamolo. La cout riga restituisce qualsiasi valore archiviato in result, quindi quando si esegue un'altra riga in avanti usando F10, viene visualizzata la finestra della console:

   

   Risultato dell'app: si prega di immettere l'operazione da eseguire. Formato: a+b | a-b | a*b | a/b. L'utente ha inserito 5 - 0. L'output dell'app: il 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.

Correggi l'errore "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. Apportare le modifiche seguenti in CalculatorTutorial.cpp. È possibile lasciare il programma in esecuzione mentre si modifica, grazie a una funzionalità del debugger denominata Modifica e continuazione. Aggiungere un'istruzione if dopo cin >> x >> oper >> y; per verificare la divisione per zero e restituire un messaggio all'utente se accade. 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 << "Math error: 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 fino a quando deve fermarsi per chiedere l'input dell'utente. Immettere 10 / 0 di nuovo. Viene ora stampato un messaggio più utile. All'utente viene richiesto un input maggiore e il programma continua l'esecuzione normalmente.

   

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

   Annotazioni

   Quando si modifica il codice in modalità di debug, è possibile che il codice diventi obsoleto. Ciò si verifica quando il debugger esegue ancora 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. In alcuni casi, potrebbe 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 collegamenti Esegui ed Esegui debug

   • F5 o Debug>Avvia debug, avvia una sessione di debug, se non è già attiva ed esegue il programma fino a quando non viene raggiunto un punto di interruzione o il programma richiede l'input dell'utente. Se non è necessario alcun input utente e non è disponibile alcun punto di interruzione, il programma termina e la finestra della console si chiude al termine dell'esecuzione del programma. Se il programma restituisce l'output alla console, usare CTRL+F5 oppure impostare un punto di interruzione prima di premere F5 per lasciare aperta la finestra.
   • CTRL+F5 o Avvia debug>senza eseguire debug, esegue l'applicazione senza passare alla modalità di debug. Questa operazione è leggermente più veloce rispetto al debug e la finestra della console rimane aperta al termine dell'esecuzione del programma.
   • F10, noto come Procedura dettagliata, consente di scorrere codice, riga per riga e visualizzare il modo in cui viene eseguito il codice e quali valori di variabile si trovano in ogni passaggio dell'esecuzione.
   • F11, noto come Step Into, funziona in modo analogo a Step Over, eccetto che entra in qualsiasi funzione chiamata sulla riga di esecuzione. Ad esempio, se la riga eseguita chiama una funzione, premendo F11 il puntatore viene spostato nel corpo della funzione, in modo da poter seguire il codice della funzione in esecuzione prima di tornare alla riga in cui si è iniziato. Premendo F10 passi sopra la chiamata di funzione e si sposta alla riga successiva; la chiamata di funzione si verifica ancora, ma il programma non si sospende per mostrare cosa sta facendo.

Chiudere l'app

• Se è ancora in esecuzione, chiudere la finestra della console per fermare 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 sito Web https://git-scm.com/ è 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. Ecco come fare:

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 compilato automaticamente a seconda del percorso della tua cartella. Per impostazione predefinita, il tuo nuovo repository è privato, il che significa che sei 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 e spingi.

   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

Congratulazioni! È 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++