Ciao e bentornato.
In questa conferenza, mi piacerebbe per parlare di
cosa significa creare un programma c.
Quindi ci sono quattro compiti fondamentali nella creazione di qualsiasi programma c.
E quali sono questi compiti includere la modifica, la compilazione, il collegamento
e l'esecuzione.
Abbiamo parlato dei diversi passaggi che impiegherai quando scrivi un programma
in c in base alle tue esigenze per capire i requisiti, progetterai il tuo
codice, sei scriverai il tuo codice, poi lo testerai ed
eseguirai il debug e così via e poi mantenerlo.
Quello di cui sto parlando qui è cosa in realtà devi farlo quando
inizi a scrivere un programma. Abbiamo parlato sono importanti anche l'editing, la compilazione
ma anche il collegamento e l'esecuzione.
E di cosa voglio parlare ecco i dettagli di questo.
Quindi questi compiti diventeranno seconda natura per te perché lo
farai ogni volta che scrivi un programma c.
Stai per modificare il tuo
file codice sorgente, compilerai, collegherai, e poi corri.
Stai per fare questo molto, molto spesso.
Quindi i processi di modifica, la compilazione, il collegamento e l'esecuzione sono
le stesse per lo sviluppo programmi in qualsiasi ambiente con
qualsiasi linguaggio compilato.
Questo non è esclusivo di c.
Se stai scrivendo java, un file java programma, stai per scrivere il
codice sorgente, stai andando per compilare il codice sorgente.
Collegamento: potresti non esserne così consapevole di in java ma farà una sorta
di collegamento e ne parleremo su cosa sia il collegamento, quindi
eseguirai il programma.
Farai tutto questo.
Quello che sto descrivendo qui ancora una volta è come è fatto in c.
Quindi l'editing è esattamente quello che penseresti che lo sia.
È il processo di creazione e modificando il
codice effettivo, il codice sorgente c.
Il codice sorgente c sta andando essere all'interno di un file.
E conterrà tutto le dichiarazioni e tutte le
istruzioni che scrivi.
Tutti i file del codice sorgente c terminano con il . c, ed è così che puoi
identificare che è un file di codice sorgente.
Prima di ciò . l'estensione c sta andando per essere chiamato il
nome di base, si desidera che i nomi dei file siano significativi.
Se scrivi un programma in c che aggiunge due file numeri, potresti avere un
file chiamato add. c, che contiene un codice sorgente.
E ricorda che la maggior parte dei c programmi avranno molti
molti file diversi.
Quindi i tuoi file dovrebbero avere un buon nome.
Ma il modo in cui puoi identificarti c il codice sorgente è il. estensione c.
Contengono tutti il file. estensione c.
Ora, quando modifichiamo il nostro codice per questa classe, utilizzeremo un
ambiente di sviluppo integrato.
Non stiamo solo andando utilizzare un semplice editor.
Un esempio di un semplice editor sarebbe qualcosa come wordpad.
Useremo qualcosa che ha un editor ma ha anche molte altre
cose che ti aiutano scrivi il tuo codice in modo più efficiente.
L'IDE - e questo è indicato come IDE, ambiente di sviluppo integrato.
Quello che useremo per questa classe è
Blocchi codice, tratterò in dettaglio, ma useremo blocchi di
codice per l'attività di modifica.
Ma puoi usare quello che vuoi.
Se vuoi usare il blocco note, se
tu vuoi usare qualcosa di ancora più minuscolo, puoi Atom, c'è IDE di visual
studio, ma quello che tratteremo qui è come per modificare il codice e i blocchi di codice.
E questo è un bel ide e il file motivo per cui l'ho scelto
parleremo più in dettaglio, ma lo è multipiattaforma e facile da usare.
Quindi la modifica è la base processo, scrivendo il codice.
Compilazione.
Sappiamo cosa fa un compilatore.
Ci vuole solo un livello così alto codice lingua e e
lo converte in linguaggio macchina, e anche rileva e trova errori nel codice.
Dopo aver modificato il codice, sei eseguirà il compilatore.
Quindi l'input per il compilatore è sarà tutto il tuo
codice sorgente, tutto il tuo. c file tutto ciò che stai modificando.
E ancora, un programma c può avere molti file di origine.
Ma gli input per il compilatore lo sono questi file sorgente, la compilazione
stessa che converte questo codice è un processo in due fasi.
Viene chiamata la prima fase la fase di pre-elaborazione.
Durante il quale il tuo codice potrebbe essere modificato o aggiunto a.
E la seconda fase è il compilazione vera e propria, genera il codice
in linguaggio assembly.
E ne parleremo più avanti dettaglio, questa fase di pre-elaborazione.
Ma devi solo sapere ora che ci sono due fasi quando
fai la compilazione.
Quello su cui ci concentreremo o quello che è facile da capire
è la generazione del codice oggetto.
Quindi il compilatore sta per guarda ogni affermazione e
si assicurerà che il file la sintassi è corretta e che la semantica
del linguaggio è soddisfatta.
La sintassi è assicurarsi che il file la struttura del codice è corretta, che
hai punto e virgola nel file fine
della dichiarazione, che stai usando tipi di dati, che sei - sei seguendo le regole della lingua.
La semantica è il significato delle parole.
Quindi se usi un if parola chiave, questa è una condizione.
La semantica avviene in fase di compilazione creando una tabella dei
simboli e così via.
Ma il compilatore è importante.
Genererà questo codice oggetto.
Ti dirà se tu hanno errori nella sintassi.
A volte può anche riconoscere indipendentemente dal fatto che si disponga o meno di codice
morto in cui fondamentalmente il codice non viene utilizzato.
Non trova errori logici.
Trova solo errori di sintassi.
Anche in questo caso, la sintassi è regole e linguaggio.
Gli errori logici sono il significato.
Come se avessi fatto un errore in logica, potresti commettere
un errore nella funzionalità.
Quindi il tuo codice può essere eseguito, può essere compilato, ma potrebbe non funzionare come previsto e
questo viene definito errore logico.
Il compilatore non lo dirà se hai un errore logico.
Se intendevi chiedere all'utente un file numero invece di una stringa di caratteri o chiedi all'utente
l'ultimo nome prima del nome che è
un errore logico. Il compilatore non sta andando per dirti quei tipi di errori.
Errori tipici segnalati da compilatore saranno cose
come variabili non dichiarate, espressione che non è
conforme alla sintassi, non ne hai il diritto parentesi, conosci i blocchi
che non hanno blocchi finali.
Diventerai molto molto familiare con gli errori del compilatore
e il loro significato.
Si spera, dopo che hai imparato il linguaggio c ed esegui
il compilatore, vedrai un errore e sarai
in grado di risolverlo immediatamente.
Dire whoops ha dimenticato una sintassi o whoops ha dimenticato un punto
e virgola, oh, ho dimenticato di fornire un diritto parentesi quadra per terminare quel blocco di codice.
Diventerà una seconda natura.
Quindi, dopo aver risolto tutti i file errori e la
tua compilazione ha esito positivo, sta andando a tradurre in linguaggio assembly e
generare questo codice oggetto.
Quindi l'oggetto reale il codice è un file. o file.
È il vero riepilogo codice della lingua che viene eseguito.
Ha un'estensione. obj o. o. obj tipicamente su Windows sarà l'estensione. o su Linux o Macintosh il sistema sarà l'estensione.
Vedrai quel file generato dopo aver compilato il codice.
E questa è solo la fase finale
della compilazione, questo è il vero linguaggio assembly.
Sarà binario, esso non sembra un testo che non sarai
in grado di guardarlo.
Avrà solo un file . o estensione, ed è ciò che genera
il compilatore.
Il modo in cui esegui il compilatore in c si utilizza effettivamente un comando.
Probabilmente non avrai
bisogno di farlo molto perché l'ide, l'editor nello sviluppo integrato è lo farò per te semplicemente facendo
clic su un'opzione di menu, ma è importante sapere cosa sta succedendo.
Quindi quando emetti il compilatore comando, in
genere utilizza un compilatore GNU che è un comando gcc.
Ma al livello di base, corri e basta un programma compilatore cc o gcc.
Esegui quel programma e quindi si specifica l'input.
Ricorda, il compilatore accetta come input i file di origine.
Si specifica l'input utilizzando un file -c flag e quindi specificando
i file di origine, uno dopo l'altro.
Quindi gli esempi qui sono cc-cmyprog. c o se stai usando il compilatore GNU, che
è popolare gcc-c.
E se ometti il flag c il tuo anche il programma
verrà automaticamente collegato, il passo successivo.
Ma è davvero facile eseguirlo compilatore se ti trovi nell'interfaccia della
riga di comando.
È ancora più facile se lo fai usa un'opzione di menu che probabilmente
faremo in questa classe.
Ma ancora una volta, ci vuole input, i file sorgente c.
Nei blocchi di codice, come ho
detto, starai solo facendo clic su un'opzione di menu e lo farà compilare
automaticamente un collegamento e quindi fare clic su un altro menu opzione verrà eseguito automaticamente.
Ma ancora una volta, cosa sta succedendo il cofano è che stai effettivamente inviando il
comando del compilatore con -c flag e i file di origine di input.
Dopo la compilazione, si collega. Come ho detto, ogni linguaggio di programmazione ha un
collegamento, ma molto a volte è trasparente, non saprai nemmeno
cosa sta succedendo.
In c, il processo di collegamento è importante perché non è sempre trasparente.
Ma con la maggior
parte degli IDE moderni oggi, lo è, ma devo sottolineare che è importante in c.
Quindi, dopo che il programma ha stato tradotto in questo. vecchio codice il suo codice oggetto, esso quindi
è pronto per essere collegato.
Il motivo per cui colleghiamo è se lo
siamo usando le librerie esterne dobbiamo prendere tutte quelle altre librerie e inserirli in un unico programma.
Quindi il collegamento sta solo ottenendo tutto le dipendenze in atto e
la creazione di un file eseguibile effettivo.
Così la . o file sono gli oggetti.
Quindi colleghi tutti i file . os in un eseguibile.
E ancora, questo è di
solito trasparente, di solito avviene automaticamente durante la compilazione.
Ma ancora una volta, potrebbe non essere così potresti dover eseguire un comando
separato, come -l o qualcosa del genere.
Ma ci vogliono tutti quegli oggetti file e crea un eseguibile.
E l'eseguibile è ciò che esegui.
Quindi combinerà tutti questi.
E poi si combinerà anche.
E potresti averlo. os che sono librerie aggiuntive, che altri programmi che potresti voler
usare qualcun altro ha scritto
o altre biblioteche fornite con il linguaggio c.
Prenderai tutto quelli e metterli insieme.
E la fase di collegamento lo farà rileva e segnala anche gli errori.
Sono due fasi separate.
Il collegamento, di nuovo, di solito sarebbe come errori di ridefinizione o stai tentando di
chiamare una funzione che non esiste.
Quindi se non ce l'hai. o file in compone l'intero programma, si verificherà
un errore di collegamento.
E dovrai avere tutti i file. o di.
E ancora, il. o di potrebbe anche non essere tuo.
Possono venire con la stessa lingua, possono far parte della libreria standard o possono
venire con un'altra programma che qualcun altro ha scritto.
Ma hai bisogno di tutti quelli. o di per formare un eseguibile.
Quindi le librerie di programmi supportano e estendere il linguaggio C fornendo routine per eseguire operazioni
che non fanno parte della lingua.
Le librerie di input e output sono esempio,
libreria matematica, librerie di manipolazione di stringhe.
Questa è la stessa cosa se lo sei familiarità con il programma Java,
è la stessa cosa dell'API Java.
È la stessa cosa dei pacchetti.
È questo il concetto
di voglio scrivere dati in un file Non
voglio implementarlo da solo, sono utilizzerà una libreria esistente fornita con la lingua.
È ancora scritto in c, è solo qualcuno c viene con quello.
Quindi ce ne
sono di tutti i tipi diverse librerie che impareremo e utilizzeremo.
Questo accade parte di la fase di collegamento.
Quindi un fallimento durante la fase
di collegamento significa che ancora una volta devi
tornare indietro e modificare il tuo codice sorgente per fare sicuro che
puoi trovare quel file oggetto, quindi molti degli errori di solito significa che devi solo includere un file o qualcosa del genere. Questo diventerà anche una seconda natura.
Successo, se hai finito compilando con successo, hai finito di collegare con
successo, quello produrrà un file eseguibile.
In un ambiente Windows, il
file eseguibile avrà l'estensione. estensione exe.
In Linux e Windows, lo farà basta avere per impostazione predefinita un file. su.
Puoi cambiare il nome di un file. su a qualcosa di
più significativo semplicemente emettendo qualcosa insieme con il comando del compilatore.
Ma anche la maggior parte
degli IDE in blocchi di codice avrà un programma
di compilazione e collegamento in una singola operazione e lo farà produrre l'eseguibile e quindi puoi semplicemente fare doppio
clic sull'eseguibile oppure puoi eseguire l'eseguibile da un comando o dall'opzione di menu.
Ma no al livello basso se lo sei su Linux,
vedrai un file a. out per impostazione predefinita come eseguibile. Su Windows vedrai un file. EXE.
Un programma di qualsiasi dimensione significativa consisterà in diversi file di codice sorgente,
come ho detto prima.
Ogni file di codice sorgente richiede l'estensione compilatore per generare
il file oggetto, che deve essere collegato.
Il programma è molto più semplice gestirlo suddividendolo in una
serie di file sorgente più piccoli.
Dovrai usare molte sorgenti file e non vuoi un file sorgente
che contenga 5000 righe di codice.
Non è coerente.
Non è facile da gestire.
Quindi creerai dei file che contengono
codice sorgente e il codice sorgente sarà specifico.
Avrà un file funzionalità specifica.
Lo rende molto più facile sviluppare ed è
molto più facile da eseguire il debug ed è molto più coeso.
Quindi avrai molti file sorgente più piccoli.
Non vuoi file sorgente di grandi dimensioni con migliaia di righe di codice.
E tutti questi file sorgente lo sono andando a costituire l'intero programma.
Avranno tutti il loro proprio . o, e saranno
tutti input per il compilatore.
Tutti questi concetti che fanno up
del programma, essenzialmente sono anche considerati un progetto.
Puoi pensarlo come quello a un livello più alto.
È il tuo progetto, è il tuo programma.
Dopo aver finalmente fatto tutto questo e l'hai collegato, hai il tuo
file eseguibile, è quindi possibile eseguire il programma.
Nella maggior parte degli IDE, questo è solo sarà un clic del
menu o puoi fare doppio clic in Windows, puoi fare doppio clic sul file exe.
E se sei su Linux, devi solo digitare un file. su.
Ora quando a. devi avere alcuni permessi quindi devi forse emettere un comando di modifica
della modalità, ma per eseguirlo puoi dire. /un. e questo eseguirà il programma dalla
riga di comando Linux.
Ma di nuovo di solito non devi preoccuparti di questo. Quindi la fase di
esecuzione è quella in cui esegui il tuo programma.
Ciascuna delle dichiarazioni del programma viene eseguito in sequenza a turno.
Se il programma richiede qualsiasi
file dati dall'utente, il programma si fermerà e riceverà quell'input.
È possibile ottenere l'input tramite tastiera o può ottenere l'input tramite l'interfaccia utente grafica, se
disponibile librerie per questo nel tuo codice c.
Risultati visualizzati dal programma vengono visualizzati
in una finestra chiamata console.
E lo mostreremo voi esempi di questo quando parliamo di
blocchi di codice.
Ma quando esegui il tuo programma, in genere, vedrai l'output.
Non sempre, a volte i programmi lo faranno fare cose che non producono output.
Ma di solito producono output
e vedi l'output direttamente sul terminale o sulla console.
Genera anche la fase di esecuzione un'ampia varietà di condizioni di errore.
Quindi potresti produrre il torto
output che è solo un errore logico e devi tornare indietro e modifica il tuo codice sorgente.
Potrebbe sedersi lì e non fare nulla perché hai problemi di logica.
E infine potrebbe bloccarsi
il tuo computer che è lo scenario peggiore, il che significa che hai fatto qualcosa
di veramente brutto nel tuo programma ed è
stato così brutto che il programma è appena morto o semplicemente
o ha effettivamente causato altro programmi sul tuo sistema operativo per mandare in crash l'intero computer.
Quindi eseguendo l'applicazione effettiva c può causare problemi. Se il programma non esegue il file funzionalità prevista, quindi devi tornare indietro
e modificare la fonte
codice potrebbe essere necessario riorganizzare o riprogettare ed è qui
che noi ha parlato dei diversi passaggi.
Questo è noto come debug fase per trovare e correggere i tuoi errori.
Avremo un intero sezione
sul debug perché è così importante.
L'ho menzionato prima dei modi migliori per imparare è imparare
attraverso i propri errori.
Tornerai costantemente indietro e modificare il codice sorgente ed eseguire il debug.
L'intero processo di compilazione, il
collegamento e l'esecuzione del programma vengono ripetuti fino a quando non hai
finito, avere tutti i risultati di cui hai bisogno per la funzionalità di quel codice.
Quindi ecco, di nuovo, un altro simpatico illustrazione che mi piace fornire.
Questo è tratto da un libro chiamato Beginning C da Horton.
Ma questo è il processo che avrai.
Stai per modificare il tuo codice sorgente.
Stai per creare un file con estensione . c estensione e un nome significativo.
Utilizzerai un editor per farlo o un IDE,
ambiente di sviluppo integrato, qualcosa come i blocchi di codice.
Quindi lo compilerai.
Il compilatore sta per genera un file obj un file o.
Se non genera quel
file, ciò significa che hai degli errori e devi tornare indietro e risolverli.
Dopo aver creato i file obj, i file oggetto, devi quindi collegarli tutti
insieme per creare un file eseguibile.
E potresti anche avere errori in quella fase
in cui non sono collegati correttamente.
Devi tornare indietro e modifica il tuo codice sorgente.
Una volta che in realtà non hai
errori e hai un file eseguibile, puoi quindi eseguire il tuo programma.
E ancora, dopo aver eseguito il tuo file programma, potresti ancora avere errori perché
potrebbero esserci errori logici.
Quindi torneresti indietro e modifica il tuo codice sorgente.
Quindi questo diventerà un
file processo ripetitivo che conoscerai molto bene.
Modifica, compila, collega, esegui.
E questo di nuovo è tipico cosa fai in tutte le lingue.
Lo farai finita e più e più volte finché il tuo
programma non soddisfa tutti i tuoi requisiti.