Ciao e bentornato.
In questa conferenza, voglio parlare di alcuni errori comuni che farai durante
la programmazione in c.
Alcuni di questi potrebbero avere familiarità con le tue
sfide precedenti e hai già riscontrato questi errori, ma questi
sono i tipi di errori più comuni.
Il primo è molto, molto ovvio. Manca un punto e virgola.
Ricorda che tutte le istruzioni in c finiranno con un punto e virgola.
Se non ce l'hai, il compilatore si lamenterà.
Quindi inserire un punto e virgola in modo errato o mancare completamente un punto e
virgola è un errore molto comune. In questo caso, stiamo posizionando male un punto e virgola.
Abbiamo una dichiarazione if. Mettiamo un punto e virgola alla fine dell'istruzione if.
E questo fa sì che il comportamento del programma sia completamente diverso.
Questo verrà effettivamente compilato.
Quando perdi un punto e virgola e non lo hai nemmeno incluso, non verrà compilato.
Ma in questo caso, il valore di j sarà sempre impostato a zero
perché è stato inserito il punto e virgola sull'istruzione if.
Quindi il punto e virgola è perfettamente valido per averlo dopo l'istruzione if.
In realtà rappresenta l'istruzione null.
E quindi, non hai un errore da parte del compilatore,
ma questo causerà un problema perché j non sarà mai e poi mai impostato a zero.
E questo tipo di errore può essere comune anche nei loop.
Quando hai un ciclo e metti il punto e
virgola alla fine del ciclo for e poi potresti avere una parentesi, dove
non hai la parentesi perché avrai un errore se hai la parentesi, molto comune.
Un altro è confondere l'operatore di uguale con l'operatore di uguale a uguale.
Specificamente menzionato che l'operatore è uguale a uguale
a non confronta le stringhe. Quindi, se usi uguale a uguale a
quando confronti le stringhe, non è valido. Metterà solo a confronto i riferimenti.
Ma se in realtà intendi assegnare un valore a una variabile
e invece usi uguale a uguale a, avrai un compilatore.
Ora, se provi a confrontare due elementi, come due
numeri interi all'interno di un'istruzione if e invece usi l'operatore
di assegnazione, in realtà non avrai un
errore del compilatore, ma quell'espressione restituirà sempre true.
Quindi, quando usi l'uguale e non usi l'uguale uguale
a, questo di solito è fatto nell'istruzione if while do, all'interno dell'espressione booleana.
E questo è valido tranne che
ha l'effetto di assegnare a qualcosa invece di eseguire qualcosa.
Quindi in questo
esempio, se abbiamo se a è uguale a 2, stiamo assegnando 2 a a.
È sempre impostato su true perché è un'affermazione vera perché non fallisci
mai quando si esegue un compito. E quindi printf verrà sempre eseguito.
Quello che volevi veramente fare qui è dire se a è uguale a.
Quindi è molto comune usare gli uguali anziché gli uguali è uguale a e
quindi non si verifica un errore del compilatore.
Se si utilizza uguale a uguale nella situazione
sbagliata, è possibile che si
verifichi anche un comportamento imprevisto, ma si verificherà un
errore del compilatore se lo si utilizza in modo errato per l'assegnazione.
Ma fai attenzione a questo con gli uguali invece che con gli uguali è uguale.
Omettere dichiarazioni di prototipi.
Ho detto che è molto importante dichiarare sempre le tue
funzioni all'inizio del file prima di usarle.
Tuttavia, questo non sempre accade ed è un errore molto comune.
E di solito, ciò che accadrà è che riceverai un errore di dichiarazione
implicito nel compilatore.
In questo esempio, se hai la radice quadrata definita più
avanti nel programma rispetto a dove la stai invocando o in
un altro file e
non l'hai dichiarata esplicitamente, avrai alcuni avvertimenti.
Il compilatore supporrà che la funzione restituisca un int.
È sempre più sicuro includere quella dichiarazione del prototipo in
alto per tutte le funzioni
che chiami, esplicitamente
o implicitamente, includendo il file di intestazione corretto nel tuo programma.
Ma quando non lo includi, quelle dichiarazioni di prototipo possono
avere errori.
Impossibile includere il file di intestazione che include la definizione per una
funzione di libreria di programmazione c utilizzata nel programma.
Quindi, in questo caso, vuoi riutilizzare del codice. Forse hai la funzione printf
e vuoi visualizzare un output, ma non includi il file di intestazione lib standard.
È un errore. E questo ti verrà solitamente detto dal compilatore.
Ci sarà un problema di collegamento
con quella funzione.
Quindi, in questo caso, abbiamo una risposta doppia uguale al valore della radice quadrata 1.
Se questo programma non include la matematica. file di intestazione, questo
genererà un errore che la radice quadrata non è definita.
Proverà a collegare i file oggetto. Non avrà una matematica. o.
E dirà, ehi, stai chiamando la radice quadrata, ma non c'è implementazione per questo.
Quindi assicurati di includere le intestazioni corrette
per tutte le tue invocazioni di funzioni, specialmente dalla libreria standard.
Confondere una costante di caratteri in una stringa di caratteri.
Quindi qui, se il testo è uguale a virgolette singole, si
tratta di un singolo carattere assegnato al testo.
Se abbiamo una variabile denominata text e la assegniamo tra virgolette, si
tratta di un puntatore alla stringa di caratteri.
Questo non è valido per un
singolo carattere.
E questo in realtà abbiamo parlato di
costanti di stringa e di assegnarle a matrici di caratteri.
E come non puoi farlo con gli uguali e devi
effettivamente farlo con la copia stella.
In questo caso, quando diciamo che il testo è uguale a, sta assegnando un puntatore
e questo in realtà non è valido neanche
e guarda cosa dovresti fare è che dovresti fare il testo
della stella uguale a o la copia della stella se non lo fai voglio
assegnarlo direttamente in questo modo.
Ma hai capito il succo.
Utilizzando un a all'interno di virgolette singole rispetto a un carattere
all'interno di virgolette completamente diverse, carattere contro stringa.
Nel primo caso, il testo viene normalmente dichiarato come una variabile char.
E nel secondo caso, dovrebbe essere dichiarato come puntatore di tipo a un carattere.
E se vuoi assegnare un valore a quel
puntatore diverso dal puntatore stesso, dovresti de-referenziarlo.
Questo in realtà non è corretto perché se è
un puntatore invece di assegnare un indirizzo, gli stai assegnando una stringa, quindi
non ha senso.
Usando i limiti sbagliati per un array, array fuori dai limiti eccezione.
Qui, stiamo dichiarando un array intero di 100 dimensioni e quindi un
paio di variabili I e sum con solo alcune inizializzate.
E passiamo attraverso il nostro ciclo, diciamo che per I è uguale a 1 I è minore di uguale a 100.
Non è corretto perché la dimensione di cento significa che ci
sono cento elementi nell'array. Ma gli array sono a base zero.
Quindi il primo elemento è zero. L'indice massimo a cui
è possibile assegnare o accedere nell'array è 99.
Questo sta andando a meno che uguale.
Quindi qui avrai un errore di fuori limite.
Questo non è un
pedice valido perché questo ciclo andrà fino a 100.
Probabilmente è anche sbagliato perché inizi da 1.
Se davvero volessi il primo elemento di questo array, inizieresti da 0.
Anche dimenticare di riservare una posizione aggiuntiva in un array
per il carattere nullo di terminazione di una
stringa è un problema comune.
Quando si dichiarano gli array di caratteri, devono essere abbastanza grandi da contenere il carattere di terminazione da solo.
Questo è il motivo per cui ti suggerirei
di non inserire una dimensione in un array quando lo crei se lo stai inizializzando.
Dovresti inserire la dimensione solo se non la stai inizializzando.
Se stai creando l'inizializzazione sulla stessa riga, lascia che c faccia
il lavoro per te, metterà automaticamente la dimensione giusta e includerà quel terminatore nullo.
Quindi, ad esempio, se hai una stringa di caratteri chiamata ciao,
questa è più di cinque posizioni di memoria, sei a causa di quel terminatore nullo alla fine.
Non dimenticare la dimensione dei tuoi array.
Questo è un problema comune con i puntatori di cui non abbiamo discusso molto,
ma volevo solo menzionare perché è molto comune.
Nei puntatori, quando vuoi accedere o anche istruire, quando
vuoi accedere a qualcosa
tramite un puntatore, devi usare il trattino maggiore del simbolo.
Viene utilizzato quando accedi a un elemento puntatore.
Quindi, se hai un puntatore che punta a una struttura, è così che puoi accedervi.
Se hai una struttura, non
è un puntatore, quindi puoi accedervi utilizzando un operatore punto.
Molte volte questo operatore punto e questo trattino sono maggiori di quelli
utilizzati in modo errato.
Punto per i non puntatori, trattino dei puntatori maggiore di, questo diventerà
chiaro in molti dei nostri esempi.
Omettere la e commerciale prima delle variabili non puntatore in una chiamata a scanf.
Quindi ricorda che la nostra chiamata a scanf si aspetta un puntatore come secondo argomento,
e questo significa un indirizzo.
Quando dichiariamo un tipo di dati una variabile di tipo int, non
è un puntatore.
Quindi, per consentire a scanf di memorizzare quei dati nella nostra variabile int, dobbiamo passargli la
e commerciale per dire che è un indirizzo.
Quindi questo non è
corretto, non avere la e commerciale prima del numero e la scansione
f come secondo argomento non è valido. L'unica volta che non hai la e commerciale è se stai usando un
puntatore, come un array di caratteri.
Tutti gli argomenti che compaiono dopo la stringa di formato e scanf devono essere puntatori.
Utilizzo di una variabile puntatore prima che venga inizializzata.
Quindi ecco un esempio della creazione di un puntatore e quindi del tentativo di assegnarlo.
E questo è il compito corretto in cui assegni un valore lo de-reference.
Ma quello che non abbiamo fatto qui è che abbiamo inizializzato il puntatore per
avere effettivamente della memoria allocata e
non puoi farlo in c.
È possibile applicare solo l'operatore di riferimento indiretto,
che è l'asterisco prima di un punto
o una variabile dopo aver impostato la variabile che punta da qualche parte.
Quindi deve puntare da qualche parte, in questo momento è nullo non punta da nessuna parte perché
non hai allocato alcuna memoria.
Quindi il puntatore char non è mai impostato per puntare a qualcosa, quindi l'assegnazione non è significativa.
Ciò causerebbe effettivamente un errore di segmentazione.
Un altro errore comune è l'omissione dell'istruzione break alla fine di un caso in un'istruzione switch.
Se l'interruzione non è inclusa alla fine di un caso, l'esecuzione prosegue con il caso successivo.
Quindi questo è quello che ho detto quando hai un caso, viene valutato.
E se non hai quell'interruzione lì, va direttamente al
caso successivo ed eseguirà il codice all'interno di quel caso successivo.
Quindi vuoi sempre avere delle pause nelle tue dichiarazioni di caso.
Ci sono momenti in cui vuoi avere un caso successivo a un altro
caso e loro fanno esattamente la stessa cosa,
in quel caso non avresti nulla all'interno dell'istruzione del caso.
Inserimento di un punto e virgola alla fine della definizione di un preprocessore.
Le definizioni del preprocessore ricordano che iniziano con il
numero, il simbolo della sterlina. Il preprocessore viene eseguito prima del compilatore
di solito per l'ottimizzazione.
La sintassi corretta per le definizioni del preprocessore non deve includere un punto e virgola.
Tuttavia, in c tu, prendi l'abitudine di mettere sempre un punto e virgola dopo ogni cosa.
Ma devi ricordare che se definisci alcuni dati costanti per i quali non hai
bisogno del punto e virgola, questo non è corretto.
Ciò porterà a un errore di sintassi
se viene utilizzata un'espressione del genere.
come quello. Quindi, se provi davvero a
usarlo per scoprire, andrà bene avere quel punto e virgola alla fine.
Ma quando il preprocessore viene eseguito, inserirà esattamente ciò che è in quello definito.
Quindi verrà pubblicato nella fine dei dati 999 due punti.
Questo è ciò che il compilatore vedrà e causerà effettivamente un errore, sarebbe
un errore di sintassi.
Omettere una parentesi di chiusura o virgolette di chiusura su
qualsiasi istruzione, molto comune. Quindi anche questo è direttamente correlato
alle parentesi, avendo una parentesi graffa iniziale e quindi non terminando la parentesi graffa, stessa
cosa con le parentesi. In questo caso,
abbiamo due parentesi sinistre iniziali o tre, ma abbiamo
solo due parentesi finali. Manca una parentesi finale a destra.
Sarebbe un errore di sintassi rilevato dal compilatore.
Quindi, quando si utilizza l'incorporamento tra parentesi per separare ogni parte di un'equazione, si ottiene
una riga di codice più leggibile.
Vuoi usare le parentesi.
Tuttavia, vuoi assicurarti che corrispondano tutti quando
inizi una parentesi devi avere una parentesi chiusa finale, lo stesso con le parentesi graffe.
Inizi una parentesi graffa, deve avere una parentesi graffa finale.
Quindi o ne hai troppi o ne hai troppo
poco, ma il compilatore si lamenterà, e questo è molto, molto comune.
Quindi anche la seconda riga qui manca una virgoletta di chiusura, questa istruzione di stampa.
Non abbiamo una citazione finale.
Il compilatore se ne lamenterà.
Entrambi genereranno un errore di compilazione.
A volte però il compilatore è molto fuorviante perché in realtà
non sa dove si verifica l'errore. Pensa che l'errore potrebbe essersi verificato in una riga successiva.
Quindi la riga che ti dice l'errore potrebbe essere fuorviante.
Quindi, a seconda che il
compilatore utilizzi una parentesi o una virgoletta su
una riga successiva, completerà effettivamente quell'espressione.
Quindi sposterà l'errore in un'altra riga.
Ed è quello che si lamenterà e dirà che è lì che si trova l'errore. Ma l'errore effettivo
è più in alto rispetto a dove intendevi posizionarlo.
Questi sono alcuni errori comuni che vedo fare molti programmatori
c.
Sono facili da riparare. E se li capisci
e studi
questo, saprai di non farli. Va bene farli come principianti,
ma man mano che codifichi sempre di più e fai
più pratica, ti renderai conto, ehi, ho dimenticato una parentesi, ho
dimenticato una parentesi, non ho usato gli uguali e gli uguali sono uguali correttamente ,
Sto usando i puntatori in modo errato, non ho allocato alcuna memoria.
Tutte queste cose verranno più una seconda natura. Grazie.