Ciao e benvenuto.
In questo video vi mostrerò come costruire ed eseguire il programma del video precedente.
Se ricordate, avevamo un piccolo programma che chiedeva all'utente di inserire il suo numero
preferito e poi lo stampava.
Quindi, dai video precedenti, dovreste capire che ci sono molti passaggi per creare un programma che potete
eseguire.
Bisogna compilare, collegare e poi creare il binario.
Quindi, fino a questo punto, siamo riusciti a compilare con successo.
Non vediamo alcun errore.
Ora dobbiamo prendere tutte le dipendenze esterne per questo programma, scrivere il file di intestazione standard
i o e tutte le altre librerie fornite dal linguaggio di programmazione C.
Si prende tutto questo, che può essere costituito da molti file O, e si prende tutto il codice esterno per creare un unico
eseguibile.
Giusto?
Ecco il nostro codice sorgente.
Vedrete che il codice sorgente è un po' ammassato.
È possibile rendere questo codice un po' più leggibile aggiungendo alcune nuove righe, come questa.
Lo rende solo un po' più leggibile.
Come ho già detto, l'abbiamo già compilato.
Per rinfrescare la memoria, è possibile compilare un file sorgente in molti modi diversi.
Si può fare clic con il pulsante destro del mouse sul file sorgente e dire compila, oppure si può selezionare
il file sorgente, andare su build e dire compila il file corrente.
Se selezioniamo il nostro progetto, vedremo molte opzioni diverse relative alla costruzione.
Si vede costruire, ricostruire, pulire, fermare, costruire.
Parliamo prima di pulizia.
Clean cancellerà tutti i vecchi file presenti.
Quindi ricordate prima nei video precedenti che un programma C quando viene compilato, si compila ogni file sorgente e un
programma può essere composto da molti file sorgente.
Main dot C Ci sono anche altri file?
Esistono programmi che contengono migliaia e migliaia di file sorgenti C.
Una volta compilati tutti i file C, si creano tutti i vecchi file e poi si prendono i vecchi file
e li si collega insieme per creare un unico eseguibile.
Ora, quando si seleziona il progetto, si imposta l'autoprogetto e si dice "pulisci", si
cancellano tutti i vecchi file, si eliminano tutti gli artefatti extra, si cancella l'eseguibile
del programma e si riparte da zero.
In sostanza, si ottiene uno spazio di lavoro pulito che può essere ricompilato, ricostruito, ricollegato
e ricreato.
In genere si usa clean se si riscontrano errori e se si vuole ricompilare ogni file
sorgente, perché in genere quando si esegue un compilatore C, se il codice non cambia e si prova a compilarlo,
di solito non lo ricompila.
Quindi, se avete problemi, avete molti file sorgente e vedete errori che
non hanno senso.
Può essere utile partire da uno stato di pulizia, andare su clean, pulire tutto.
Dite "pulito" e vi mostrerà esattamente questo.
In pratica rimuove tutto dalla cartella di debug della build.
Anche in questo caso, tutti quei punti os dell'eseguibile che state iniziando da zero.
È un bel modo per risolvere qualsiasi tipo di dipendenza o problema senza ricompilare l'intero
progetto per ripartire da zero.
Quindi, dopo l'esecuzione di clean, non abbiamo nulla di compilato o costruito e possiamo andare avanti e compilare
i singoli file dicendo compile e facendo clic su ciascun file.
Se si hanno molti file sorgente, questo non è un ottimo modo per arrivare all'eseguibile finale.
In genere, si vuole assicurarsi di avere il progetto dell'applicazione
e di solito si dice "build", che analizza tutto il codice sorgente del progetto e costruisce tutti i file.
Quindi, quando si preme build, si vedrà che il programma passa in rassegna tutti i codici sorgente e li ricostruisce.
Inoltre, se si fa clic con il pulsante destro del mouse e si dice ricostruisci, non si ricostruiscono tutti i file
o si ricostruiscono solo i file modificati.
E quindi si può dire build, il che rende il tutto un po' più semplice rispetto alla compilazione di ogni file sorgente.
La compilazione compila tutti i file sorgenti, ma li collega anche, in modo da poterli vedere nell'output,
giusto?
Se si va alla finestra di output della compilazione, si può vedere che per prima cosa viene emesso un comando
GCC dash C, che è il flag per la compilazione su main dot C, quindi si passano i parametri per l'ottimizzazione dell'architettura
64, alcuni standard C per il debug, 99 avvisi per tutti gli avvisi.
E poi facciamo il trattino o per collegarci alla pagina principale. cpp.
In pratica, includeremo anche alcuni elenchi di inclusione.
E poi, nel passo successivo, emettiamo il trattino zero per fare il collegamento a ogni dipendenza esterna.
In questo caso, non ne abbiamo molti, abbiamo solo un collegamento, un collegamento statico con
il trattino L e stiamo costruendo il testo dell'elenco di oggetti.
La cosa più importante è che viene creato un file eseguibile con il nome del nostro primo programma.
Vedi.
E quindi l'edificio esegue entrambe le fasi di un programma C, giusto?
Lo compila, lo collega e crea l'eseguibile.
E quindi rende le cose più semplici costruendo, invece di compilare tutto all'inizio.
Ora, si potrebbe voler compilare i singoli file solo per vedere cosa sta succedendo, per assicurarsi che il codice sorgente
sia corretto e che non sia pronto per il collegamento.
Potreste avere cinque file qui dentro.
Selezionate ciascuno di essi per dire: "Ok, ho appena scritto un po' di codice, compiliamolo,
assicuriamoci che sia tutto a posto, e poi andrò al file successivo, lo compilerò e alla fine costruirò tutto".
Ora che abbiamo un programma eseguibile creato, possiamo eseguire il nostro programma.
Quindi ci si deve assicurare di avere il programma, il progetto come progetto attivo e di averlo evidenziato;
poi si può andare su build e si può semplicemente dire run.
Ora, quando si seleziona esegui, probabilmente si aprirà un pop-up che dice: Vuoi costruire di nuovo ed eseguire?
Ora avete già costruito, quindi non ne avete bisogno.
Si può dire semplicemente "esegui".
È possibile selezionare la casella di controllo per assicurarsi che questo non venga sempre visualizzato.
E quando si corre, non sempre si ricostruisce.
Dipende da voi.
L'elaborazione della CPU richiede un po' di tempo per ricostruire tutto, ma probabilmente non è un problema.
Quindi si può sempre dire costruisci ed esegui e non avere un pop-up o si può sempre eseguire e basta.
Ora, se selezioniamo execute, l'eseguibile verrà preso e verrà eseguito.
E noterete che vi chiede di inserire il vostro numero preferito, l'utente.
È quindi possibile inserire il numero 45, premere il pulsante di invio sulla tastiera e visualizzare
l'inserimento del numero 45.
Anche in questo caso, un programma molto semplice chiede un input, visualizza un output e poi si può premere un tasto qualsiasi per continuare
e chiudere la finestra.
Ora, se torniamo alla vista dell'area di lavoro, alla finestra dell'area di lavoro, al riquadro dell'area di lavoro, o
come volete chiamarlo, noterete che abbiamo tre progetti, giusto?
Il nostro primo programma è in evidenza.
Questo è il progetto attivo.
Gli altri progetti hanno ancora i loro file sorgente, giusto?
Punto principale C, destra.
E i nostri altri progetti sono praticamente già pronti.
Ciao, Codice del Mondo.
Ma quello che non si vede è che non si vede nessuno dei file oggetto, dei file punto zero,
non si vede il file eseguibile, niente del genere.
Ora è possibile visualizzarle facendo clic sulla scheda Esplora risorse ed è possibile specificare una cartella da aprire.
Di solito questa dovrebbe essere la cartella principale in cui vengono creati tutti gli spazi di lavoro.
Quindi di solito li metto, credo di averli messi in documenti all'interno di documenti.
Ho i miei spazi di lavoro.
Vedrete che c'è molto materiale qui dentro.
Di solito è meglio metterlo in locale, ma vedrete che ci sono l'area di lavoro uno e l'area di lavoro due,
e vedrete che l'area di lavoro ha il file dot code light.
In realtà, probabilmente è meglio aprire i file dell'area di lavoro esatta, giusto?
Perché in realtà è solo quello che ci interessa.
Lo spazio di lavoro due è quello che ci interessa.
Selezioniamo quindi la cartella, l'area di lavoro 2 e chiudiamo i documenti esistenti, in modo da poter
procedere con la chiusura.
Ora abbiamo l'area di lavoro due e possiamo vedere tutti gli eseguibili di tutti
i nostri progetti e tutti i nostri file.
Si noti che c'è una cartella di codici luminosi.
La cartella Code Light contiene solo alcune delle preferenze per l'area di lavoro e così via.
Abbiamo la nostra cartella di build debug.
Questa contiene la nostra cartella binaria che contiene il nostro eseguibile e noterete che abbiamo anche una cartella del primo programma R e
che si trova all'interno di build debug, perché quell'area di lavoro, quel progetto è stato costruito e vedrete che lì dentro ci sono i nostri
file oggetto e tutte le altre dipendenze che sono state costruite in questo elenco
di oggetti.
Abbiamo il nostro primo progetto di programma, giusto?
E questo riguarda il nostro file sorgente e qualsiasi altro file make e così via.
Lo stesso vale per gli altri progetti.
E poi in fondo si vedono i comandi di compilazione, punto JSON.
Di solito viene utilizzato per il completamento del codice.
Si vede un file make e poi un file workspace.
Ma la scheda Esplora ci aiuta a vedere l'intero layout del nostro spazio di lavoro, tutti i nostri progetti, tutto ciò che è stato costruito,
tutti i file di impostazione del progetto e tutti i file sorgente del progetto, e anche tutte le dipendenze dai file di completamento
del codice e così via per lo spazio di lavoro stesso.
E quindi abbiamo parlato di pulizia, giusto?
Come pulire può effettivamente eliminare tutto, tutti i file oggetto nell'eseguibile.
Quindi, se torniamo alla vista Workspace ed evidenziamo il nostro primo progetto di programma, quando facciamo clic con il pulsante
destro del mouse e diciamo "pulisci", cancelleremo tutti questi progetti.
Quindi, se si torna alla scheda Explorer e si va al debug della build, si vedrà tutto quello che c'è dentro,
perché non è stato aggiornato.
Quindi è possibile aggiornare questa vista.
Faccio quindi clic con il pulsante destro del mouse sul nostro spazio di lavoro e dico di aggiornare la cartella build debug.
Quindi di solito viene cancellato, ma non c'è nulla al suo interno, giusto?
Potreste avere di nuovo un cestino.
Di solito questo viene ripulito.
Dipende dai permessi, ma non ci sono file vecchi.
Non avete il vostro eseguibile dopo aver fatto una pulizia.
Ora, di nuovo, se torniamo all'area di lavoro, possiamo vedere questo piccolo menu a discesa che ci dice
cosa costruire, se costruire per il debug o per il rilascio.
Quando si costruisce per il debug, si includono le informazioni di debug nell'eseguibile stesso del programma.
Di solito questo accade quando si sta sviluppando il codice.
Si vogliono informazioni di debug e nel caso sia necessario eseguire il debugger e così via.
Non è sempre una buona cosa da fare quando si rilascia un programma sul campo o a un cliente in modalità di produzione,
in modo da poter cambiare la release in release quando si sta costruendo e si vuole distribuire questo programma da
qualche parte.
Quindi, quando lo costruite, noterete che se andate nella scheda Esplora, vedrete di nuovo un aggiornamento.
Verrà visualizzata una cartella di build release, nella quale mancheranno essenzialmente le informazioni di debug, per cui non ci si dovrà
preoccupare.
In pratica, se si hanno informazioni di debug, si può generare un file di base e gli hacker
possono ottenere informazioni sul codice sorgente.
Quindi si costruisce solo il debug per la modalità debug quando si sta sviluppando e si cambia in modalità
release quando si rilascia il programma a un cliente.
Ancora una volta, dipende se si lavora da qualche parte o se si lavora per un dipendente, se si sta effettivamente
consegnando del codice da qualche parte.
Di solito non si modifica nulla nella scheda Explorer.
Fornisce solo una visione di ciò che è stato costruito, degli eseguibili e così via.
Di nuovo, vi ho detto che vedete alcuni file di aiuto.
È possibile esaminare alcuni di questi aspetti.
Alcuni di questi elementi saranno generati automaticamente.
Qui potete vedere un file make.
Si tratta di un file make che può essere generato in base alle impostazioni del progetto.
Questo è un file make per l'intero spazio di lavoro.
È possibile esaminare programmi specifici e vedere alcuni dei file di make che vengono generati di nuovo, ma di solito non è il caso di fare
confusione con queste cose.
Anche in questo caso si fornisce un file make da compilare.
A volte, quando si verificano degli errori, si può guardare il file make per vedere esattamente cosa sta succedendo.
Forse qualcosa non è stato generato correttamente.
Il codice, come a volte accade, presenta alcuni bug a seconda del sistema di produzione utilizzato.
Anche in questo caso, di solito si utilizza il sistema di creazione dei file UNIX se si utilizza Windows, mentre se si utilizza
Linux o Mac OS, si utilizza il sistema predefinito.
In pratica è tutto qui, giusto?
È possibile chiudere questi file, ma è possibile vedere cosa succede nell'Explorer e nelle viste dell'area di lavoro.
Ora nella vista Workspace, sempre selezionando un progetto, si può anche dire stop, build.
Quindi a volte la compilazione e la creazione dell'eseguibile possono richiedere molto tempo.
Se avete migliaia di file, potreste costruire per 30 minuti.
Quindi stop, build permette di interrompere la costruzione di qualsiasi cosa, la compilazione e il collegamento di qualsiasi
progetto.
Anche in questo caso, è utile quando si ha un lungo processo di compilazione, ma di solito non lo si vede in parte del codice che
scriveremo per la nostra classe.
Un'altra cosa che potrebbe essere utile è che se si evidenzia la vista dell'area di lavoro, si possono costruire tutti
i progetti in un colpo solo.
Si può dire build workspace o clean workspace e cancellare tutte le dipendenze per tutti i progetti.
Ma se si dice di costruire l'area di lavoro, si costruiscono tutti i progetti, indipendentemente dal fatto che siano attivi, e questo
è ciò che si vede nella finestra di output.
Giusto.
Stiamo costruendo il Progetto tre, il Progetto due e il nostro primo programma.
Quindi, ancora una volta, una rapida panoramica di come si può costruire ed eseguire il codice dal progetto attivo, di alcune
impostazioni e di come si può vedere la scheda Explorer.
Grazie.