Ciao a tutti.
In questo video configureremo Code Light in modo che funzioni con il compilatore installato.
Quindi, ovviamente, il prerequisito per questo video è che il compilatore deve essere installato e che code light deve essere
installato.
Ok, allora iniziamo.
Ho un'icona qui.
Scorciatoia per il codice luminoso.
Faccio doppio clic su di esso e si aprirà per la prima volta Code Light, con la scritta
Welcome to the setup wizard.
Eseguiamo la configurazione guidata.
È sufficiente farlo una sola volta.
Selezionerò quindi il profilo di sviluppo, che sarà C, C plus plus development.
Selezionerò il prossimo.
E ora possiamo cercare un compilatore.
Facciamolo.
Probabilmente non troverà il compilatore che abbiamo installato, perché non sempre trova i compilatori preinstallati,
ma proviamo.
Se lo trova è ottimo, altrimenti lo installeremo manualmente.
Quindi, in ogni caso, siamo coperti.
Quindi seleziono la scansione e mi dice che non è stato possibile individuarlo.
Non c'è problema.
Volete installarne uno adesso?
No, l'abbiamo già installato, quindi selezionerò il prossimo.
Si può notare che ha trovato il compilatore Rust.
È un linguaggio di programmazione diverso e va bene così.
Potete ignorarlo.
Selezionerò il prossimo.
Scegliete la combinazione di colori che desiderate.
Utilizzerò questo schema predefinito.
Normalmente userei lo schema scuro perché è più facile da vedere, ma userò questo
perché penso che si veda meglio in video.
Selezionerò il prossimo.
Questa finestra di dialogo chiede informazioni sugli spazi bianchi, sui rientri e così via.
Lasciare le impostazioni predefinite e fare clic su Fine Il codice si chiude e poi si
riapre.
Quindi la prima cosa da fare è che, poiché non ha trovato il compilatore nel setup, dobbiamo installare
manualmente il compilatore nella linea di codice.
È davvero facile fare clic su impostazioni e poi su impostazioni di costruzione.
E poi facciamo clic sul simbolo più blu.
Sullo schermo potrebbe essere verde.
Dipende dal tema chiaro o dal tema scuro.
Quindi vogliamo fare clic su questo punto.
Ricordate che siamo nella scheda dei compilatori.
Voglio fare clic su questo, e in più c'è scritto Aggiungi un compilatore esistente.
Quindi lo farò.
Quindi, dopo aver premuto il più, si vedrà questa finestra di dialogo.
Vogliamo navigare nel percorso in cui abbiamo installato il nostro compilatore Cygwin C.
Quindi l'ho installato nell'unità C.
Quindi si deve andare all'unità C e selezionarla, quindi andare a Cygwin 64 o al punto in cui è stato installato.
Per impostazione predefinita, si trova in C Cygwin 64 e all'interno di Cygwin 64 si trova la directory bin.
Da qui è possibile selezionare la cartella e poi darle un nome, chiamiamola
Cygwin, in modo da sapere qual è.
E noi diciamo: "Ok".
A questo punto, se si seleziona la scheda Strumenti o se è già stata selezionata, si vedranno
tutte le impostazioni di costruzione compilate.
Alcuni di questi non sono corretti, quindi è necessario correggerli.
Il compilatore C plus plus non vi interessa, non dovete preoccuparvi.
Non l'abbiamo installato.
Per il compilatore C, invece, è meglio usare GCC.
Quindi, se si seleziona il compilatore C, poi il punto, il punto, il punto, si può navigare di nuovo
nella directory bin e selezionare GCC dot exe.
Quindi si va laggiù e si seleziona GCC dot exe per eseguire il compilatore GCC per il nome dell'assembly.
È possibile utilizzare il punto, il punto, il punto o digitarlo nel programma
che si desidera eseguire come ASX.
Per il nome dell'assemblatore, il linker che si desidera utilizzare è GCC.
Quindi, ancora una volta, è possibile modificare manualmente o premere il punto, punto, punto.
Si deve solo verificare che questo sia GCC dot exe per il linker degli oggetti condivisi.
Anche in questo caso, useremo GCC.
Quindi, ancora una volta, possiamo usare il punto punto punto o semplicemente dire GCC punto x trattino condiviso trattino minuscolo f scegliere
per l'archiviazione che andremo avanti e useremo di nuovo RDX.
Con l'RCU come argomento del programma.
La marca che useremo è la X all'interno del bin.
Quindi dovrebbe essere corretto.
In caso contrario, dovrebbe essere make dot x.
E per quanto riguarda gdb, vogliamo modificarlo nuovamente per usare gdb, in modo da poter andare al punto punto punto e andare a gdb.
Punto XY e possiamo usarlo.
E poi si vuole essere certi che queste impostazioni siano davvero importanti.
È quindi opportuno mettere nuovamente in pausa il video per assicurarsi che tutto sia di nuovo corretto.
C più compilatore non ha importanza.
Compilatore C GCC x nome assemblatore ASX Xqcs Xqcs Xqcs condiviso per l'oggetto condiviso nell'archivio.
A. x.
Quindi si può procedere con l'applicazione e con la selezione.
Ok.
Va bene.
Quindi, in Codelab, consentitemi di fare lo schermo intero.
Per quanto riguarda la luce del codice, qui abbiamo diverse finestre, che analizzerò in dettaglio nei prossimi video.
Abbiamo una visualizzazione dell'area di lavoro ed è qui che creiamo gli spazi di lavoro, una raccolta di progetti, in modo da avere
un'area di lavoro con il Progetto uno, il Progetto due e così via.
Ognuno di questi progetti è un programma che scriveremo qui.
Possiamo creare una nuova area di lavoro, aprire un'area di lavoro e molte di queste funzioni sono accessibili anche
dalle schede.
In queste moderne interfacce utente, di solito ci sono 4 o 5 modi per fare la stessa cosa.
Ok, creiamo un nuovo spazio di lavoro.
Selezionerò nuovo per assicurarmi che ci sia un'area di lavoro C plus plus.
Questo è ciò che faremo.
Faccio clic su OK.
Qual è il percorso del mio spazio di lavoro?
Lo inserirò proprio nella mia cartella utente.
E quello che voglio fare è creare una nuova cartella in cui creare tutti i miei spazi di lavoro.
Quindi, facciamolo.
Vengo qui e, proprio nella mia cartella home, creo una nuova cartella che
chiamerò workspaces o my workspaces o come preferite.
L'importante è che non ci siano spazi, né caratteri speciali, né punti e tutti i tipi di caratteri
strani.
Basta dargli un nome semplice, come spazi di lavoro.
E andrà bene così.
Tutto qui.
Quindi ho la cartella.
Lo sceglierò.
E qual è il nome del mio spazio di lavoro?
Questo spazio di lavoro sarà, diciamo, l'area di lavoro 1 o la Sezione 1 o come vogliamo chiamarla.
Lo chiamerò Spazio di lavoro uno.
Si può vedere qui sotto dove verrà creato lo spazio di lavoro e si creerà un file di spazio di lavoro, assicurandosi
che questo piccolo controllo sia selezionato, creando lo spazio di lavoro in una directory separata.
In questo modo abbiamo directory separate per tutti i nostri spazi di lavoro e siamo ben organizzati.
Selezionerò.
Ok.
E si può notare che questa finestra ora è scomparsa.
Qui c'è una grande area bianca e lì c'è il nostro spazio di lavoro, il nostro primo spazio di lavoro.
Ora non possiamo fare molto con uno spazio di lavoro.
Abbiamo bisogno di un progetto all'interno dell'area di lavoro, in modo da poter selezionare l'area di lavoro e creare un nuovo progetto.
Oppure posso semplicemente fare clic con il pulsante destro del mouse sull'area di lavoro e dire nuovo progetto, ed è quello che farò.
Va bene.
Probabilmente la parte più importante di questo video è l'impostazione del progetto.
Qual è il nome del mio nuovo progetto?
Lo chiamerò Progetto Uno.
Assicurarsi di creare il progetto nella propria cartella.
Ora riempiremo queste caselle a discesa proprio qui.
Qual è la categoria?
Che tipo di applicazione stiamo costruendo?
Sarà un'applicazione per console.
Si tratta di un'applicazione non grafica che viene eseguita dal prompt dei comandi.
Il prossimo elemento da selezionare è il tipo.
E il tipo sarà fondamentalmente un semplice GCC eseguibile.
Si tratta di un programma C, quindi un semplice GCC eseguibile.
Il compilatore che useremo è stato appena creato e si spera che
sia stato chiamato Cygwin.
È quindi possibile selezionare Cygwin.
Se si lascia il nome predefinito, è necessario selezionarlo.
Il debugger che useremo è un nuovo debugger GDB e il sistema di compilazione che
useremo è il generatore di codice leggero Makefile Unix.
Quindi, anche in questo caso, si tratta di impostazioni molto importanti.
Quindi, ancora una volta, date un'occhiata a queste zampe se ne avete bisogno, ma le categorie dovrebbero essere tipo
console dovrebbe essere semplice eseguibile compilatore GCC dovrebbe essere cygwin debugger dovrebbe essere GDB debugger e il sistema di compilazione
dovrebbe essere code light, makefile generator unix.
Quindi andiamo a colpire.
Ok.
Quindi, all'interno della cartella del progetto, è stato creato un file sorgente chiamato
Main dot C dot C è l'estensione dei linguaggi di programmazione C.
Il codice è stato creato automaticamente e si può fare doppio clic su di esso, per poi vedere che l'editor
si apre con una piccola scheda progetto, un punto C principale e si vede che questo è un codice C.
Il codice C non è importante in questo momento.
Stiamo solo preparando il nostro ambiente.
Stiamo cercando di assicurarci di poter costruire, compilare e tutto il resto.
Se provate a modificare questo file, noterete che quando scrivete il codice c'è un piccolo
cerchio rosso, il che significa che il file non è stato salvato.
È sempre bene assicurarsi che sia stato salvato prima di compilare e costruire, in modo da poter premere Ctrl s per salvarlo
e vedere che il rosso scompare.
Giusto?
Oppure, se volete salvarlo, potete andare su file e dire semplicemente salva file.
Il punto rosso indica se il codice sorgente è stato salvato o meno.
Anche in questo caso, si tratta di codice C.
Non dovete preoccuparvi di questo.
Cercheremo di costruire e compilare.
Quindi avete il vostro punto C principale, noterete che potete cambiare le impostazioni del compilatore
e cose del genere selezionando la chiave inglese qui sopra.
Quindi se si seleziona la chiave inglese qui sopra.
Qui vengono visualizzate tutte le impostazioni del progetto e alcuni elementi vengono compilati automaticamente.
Perciò, in generale, vedrete alcune delle cose che abbiamo impostato automaticamente quando abbiamo installato
il compilatore Cygwin.
Quindi il generatore di Makefile è codice leggero, il generatore di Makefile, il compilatore UNIX, Cygwin
e così via.
La maggior parte di queste impostazioni può essere contrassegnata come predefinita e ne analizzeremo molte
in un prossimo video, ma in linea di massima si dovrebbe vedere compilato ciò che si è fatto prima delle impostazioni
del compilatore.
Se si seleziona il compilatore sulla sinistra, si noterà che ci sono alcuni argomenti della riga di comando
che si possono passare.
Non dobbiamo preoccuparci di C plus plus, ma per le opzioni del compilatore C, se si seleziona
il punto, il punto, il punto, probabilmente è una buona idea selezionarlo davvero.
Le caratteristiche del C 99.
Quindi si possono usare booleani e cose del genere.
Ne riparleremo più avanti.
Quindi, se si dice di abilitare le funzioni C 99, verrà passato un argomento standard C 99.
E se c'è qualcos'altro, non credo che ci serva davvero altro.
Le opzioni del compilatore.
Qui è praticamente tutto a posto, quindi potete colpire.
Ok.
E poi noterete che è appena passato in STD uguale C 99.
Anche tutto il resto può rimanere invariato se si passa al linker.
Per quanto riguarda le opzioni del linker, si può andare di nuovo al punto, punto per le opzioni del linker e selezionare
il collegamento statico.
In questo modo non avremo problemi di libreria in seguito, con il marchio di collegamento che controlla il collegamento statico
e di nuovo il colpo.
Ok.
E quindi ne parleremo più avanti in modo più dettagliato.
Ma ora tutto dovrebbe essere configurato in modo da poter provare a compilare ed eseguire il nostro codice.
Quindi andiamo avanti e premiamo applica e.
Ok.
E ora vediamo il nostro codice sorgente.
Ora possiamo provare a compilare il nostro codice.
Quindi, se andiamo su build e diciamo build project, dovremmo vedere che il codice viene costruito e che
non ci sono errori.
Perché questo è solo un codice C templato.
Ora, se si aggiunge qualche sintassi o altro, si salva il file e si prova a costruirlo di nuovo,
si può vedere un errore.
Inoltre, si vuole essere sicuri che il codice venga compilato seguendo tutte le indicazioni.
In pratica possiamo modificare il codice sorgente.
Dite qualcosa come Hello testing e poi andate avanti e costruite il progetto.
Si può sempre pulire e costruire e parleremo di queste opzioni più avanti, ma ora costruiamo
il progetto e vedremo che non ci sono errori e che tutta la configurazione è stata impostata correttamente.
Ora, se si verificano degli errori, potrebbero essere, e non si tratta di errori di sintassi, ma di qualcosa di sbagliato
nella configurazione.
Dovrete tornare indietro e andare nelle impostazioni, nelle impostazioni di costruzione, per assicurarvi
che tutti gli strumenti e i percorsi siano corretti.
Si vuole usare GCS per assicurarsi che il file make sia make dot exe e che tutto il make
dir sia blink.
Si consiglia di controllare prima tutte le impostazioni per assicurarsi che siano corrette e poi, se si riscontrano
ancora problemi, si può tornare alla scheda Chiave e andare di nuovo a Generale.
Assicuratevi di usare code light, make file generator, UNIX, sapete, cygwin.
Anche in questo caso, tutti questi elementi dovrebbero funzionare per impostazione predefinita, ma è possibile giocare un po' con le cose.
Se si continuano a riscontrare errori, pubblicare qualcosa nella sezione Domande e risposte se non si riesce a risolvere il problema.
Ma a questo punto dovreste costruire con successo.
Ora che ho compilato il programma con successo, posso eseguirlo e vedere
l'output.
Quindi posso evidenziare il progetto proprio qui nell'area di lavoro Esegui progetto e andare all'opzione
di menu sotto Costruisci e dire Esegui.
Una volta fatto ciò, il programma tenterà di essere eseguito.
Questo riquadro viene visualizzato per impostazione predefinita.
È possibile selezionare l'opzione "Ricorda", in modo che non me lo chieda di nuovo.
Non è necessario costruire di nuovo un'esecuzione.
Si può semplicemente eseguire perché, dato che l'abbiamo già costruito, si tratta di due passaggi.
Oppure si può dire costruisci ed esegui di nuovo.
In ogni caso va bene, ma non è necessario compilare di nuovo se lo si è già fatto.
Quindi dirò solo di eseguire.
Ora vedrete apparire una sorta di finestra dos con l'output del programma,
che in alto dice: Hello, testing.
È un po' difficile da leggere, ma dice "hello testing" e contiene anche informazioni aggiuntive.
Dice che il programma è uscito con codice X zero.
È una buona cosa, perché significa che non ci sono stati problemi nell'esecuzione del codice e che ha restituito zero.
Quindi c'è uno zero.
Indica anche quanto tempo ha impiegato il programma per essere eseguito e quindi premere un tasto qualsiasi per continuare.
Ora, se si eseguisse questo programma dalla riga di comando, non si vedrebbe questo output extra.
Vedremmo solo, ciao test, perché questo è l'output del codice sorgente.
La luce del codice ID è accompagnata da alcune informazioni aggiuntive che è bello avere, ma non ci servono
davvero, quindi possiamo andare avanti e premere un tasto qualsiasi per continuare e questo riquadro scomparirà così.
Ed è così che possiamo gestire il nostro programma.
E ora ci sono anche, come noterete in basso, molte schede e informazioni diverse.
Le due schede più importanti sono la scheda output e la scheda build.
La scheda Output indica cosa sta succedendo.
Dice che il programma è uscito e così via e che il programma è in esecuzione.
La scheda build è fondamentalmente ciò che accade quando si compila.
Quindi, se ogni volta che compilate e dite build e build project, noterete che vi dice
come compilare.
In questo caso particolare, manca il punto e virgola.
Quindi c'è un errore.
E ti dice che c'è un errore.
Quindi, se la compilazione è andata a buon fine, aggiungiamo il punto e virgola, diciamo "sicuro" e la compiliamo di nuovo.
Ciò che si dovrebbe notare in una compilazione riuscita è che si vede il comando esatto che viene eseguito, che abbiamo già impostato
nelle nostre impostazioni, giusto?
Vedete, GCC dot x dash C è per la compilazione.
Sta compilando il nostro file sorgente, main dot C, utilizzando gli argomenti del programma impostati
nelle impostazioni di build G dwarf two standard C 99 dash wall.
Giusto.
Tutte queste impostazioni si stanno unendo.
E poi c'è anche GCC X, che è il collegamento con l'opzione dash o.
E poi si vede il trattino statico, che abbiamo aggiunto anche noi.
Quindi, tutto questo si sta realizzando attraverso le impostazioni.
Ora, come vi ho appena mostrato, se la compilazione non va a buon fine e si verifica un errore.
Quindi, per esempio, come ho fatto prima, non c'è il punto e virgola, lo si perde e quando
si costruisce, si vedrà che c'è un errore.
Non c'è un vero punto e virgola.
In un certo senso dice che l'errore prevede il punto e virgola prima del ritorno.
E questo succede spesso, giusto?
Questi errori di sintassi sono ciò che si finisce per vedere.
In genere, se si riscontra un problema nell'esecuzione del programma, è possibile pubblicare questo messaggio nella sezione
Domande e risposte della scheda Costruisci.
E posso vedere cosa sta succedendo per aiutarvi.
Ma gli errori di sintassi sono frequenti quando si scrive il codice C.
La comprensione del compilatore e degli errori del compilatore verranno analizzati in un prossimo
video.
Ma questa scheda di compilazione è importante per vedere l'output e se la compilazione è andata a buon
fine o se ci sono errori.
Ancora una volta, errori comuni, manca il punto e virgola.
A volte gli studenti dimenticano che la D e lo standard i o.
Quindi hanno il punto e virgola.
Io lo salvo e loro lo costruiscono.
Noterete che la freccia rossa si sposta perché indica dove si trova l'errore.
Il compilatore ve lo dirà.
Quindi in questo caso avete sbagliato a scrivere IO standard. H, che è un pacchetto C che si può includere, giusto?
E se manca il punto e virgola, la freccia rossa sarebbe qui, giusto?
Ma ancora una volta, si salva la compilazione e si esegue di nuovo, giusto?
Quindi, una volta corretti questi errori, possiamo costruire di nuovo il progetto o ricostruire i progetti, è un'altra opzione.
Beh, ricostruisce tutto.
Lo pulisce e lo ricostruisce.
E poi si possono vedere le uscite.
Si può notare che non ci sono errori.
E poi ancora, si può eseguire come prima, creare un esecutore, eseguire e basta.
Ecco come compilare ed eseguire il programma e impostare tutte le impostazioni.
Se avete problemi, scrivete alla sezione Domande e Risposte.
Molte di queste domande sono state poste e hanno avuto risposta, quindi si possono esaminare, sia che si
tratti di errori di impostazione nell'ambiente di compilazione, sia che si tratti di codice vero e proprio con errori di
sintassi.
Ci sono diversi errori di sintassi che possono verificarsi.
Impareremo, nel corso del corso, a scrivere un codice C corretto.
Ma la scheda di compilazione è importante, la scheda di output è importante.
Nelle lezioni successive vedremo come impostare un modello in modo da non dover necessariamente
eseguire tutte queste impostazioni e così via.
Quando si creano progetti, è possibile creare sempre lo stesso progetto.
Il codice qui presente potrebbe non essere compreso, ma si spera che alla fine di questa lezione lo si possa capire.
Per far funzionare questo programma è sufficiente un semplice programma in C.
Grazie.