Ciao e Benvenuto.
In questa conferenza, voglio parlare di un paio di operatori che sono un po 'strani nel
senso che non penseresti necessariamente che siano operatori.
Perché tutti gli operatori che abbiamo imparato fino a questo punto in realtà indicano solo che
sai come usare il simbolo per fare calcoli sui numeri.
E questi operatori in realtà sembrano delle funzioni.
Quindi parliamo del cast nell'operatore sizeof.
Per parlare prima dell'operatore cast, devo parlarvi
un po 'delle conversioni di tipo, di come i dati vengono convertiti.
Abbiamo imparato tutto sui tipi di dati e sui diversi tipi di dati là fuori.
Ma se stai effettivamente cercando di assegnare dati a tipi diversi, ci
sono alcune conversioni implicite che avvengono nel linguaggio di programmazione c.
Quindi la conversione dei dati tra diversi tipi può avvenire automaticamente
e questa viene definita conversione
implicita dal linguaggio o esplicitamente dal programma dal programma o.
Il programmatore stesso lo sviluppatore può fare qualcosa.
Possono utilizzare un operatore di cast essenzialmente per eseguire una conversione.
I dati che vengono convertiti implicitamente sono molto
importanti perché devi capirlo perché la maggior parte dei
programmi c che svilupperai per svilupparli in modo efficace, devi capire
queste regole per queste conversioni.
Perché spesso avrai numeri interi e numeri in virgola mobile,
numeri decimali e numeri interi.
E le userai mescolandole un po 'a volte.
E quando lo fai, devi sapere come le cose vengono convertite.
Ora dovresti cercare di evitarlo il più possibile usando l'operatore cast.
Ma quando non usi l'operatore cast, capisci cosa sta succedendo.
E cosa sta succedendo qui quando assegni dati a diversi
tipi di float e
double, i dati verranno troncati o verranno promossi.
Questi sono due termini che ascolterai.
Il mezzo troncato diventa meno preciso
e promosso significa che diventa più preciso.
Quindi cerca di non mescolare questi tipi ma possono essere utili.
La cosa principale da capire è che sappiamo dalle lezioni precedenti che c è molto flessibile.
E questa è una decisione consapevole dei progettisti del linguaggio.
Quando volevano che fosse flessibile, ma ancora una volta come compromesso,
poiché questa libertà aggiuntiva ti viene
data, puoi abusarne. Quindi non abusare
di questa idea di mescolare i tipi.
Prova a usare gli stessi tipi quando puoi, interi con numeri interi, float con float.
Ma quando
non puoi, capisci le conversioni implicite o esegui
le conversioni esplicite usando l'operatore cast.
Quindi, ancora una volta, un
altro problema o un altro concetto in cui c è flessibile, ma non dovresti abusarne.
Quindi, ogni volta che un valore in virgola mobile viene assegnato a una variabile
intera in c, hai int x, float y, x
è uguale a y.
La parte decimale del numero verrà troncata.
Quindi, se hai un numero int x uguale a 0, float f
è uguale a 12. 125 e si
assegna f a x, il valore di x sarà 12.
Perderai quella precisione. Il valore verrà troncato perché
stai assegnando un float a un int. Un int sa solo come memorizzare un numero intero.
Quindi viene automaticamente convertito dal linguaggio di programmazione, dal compilatore a 12.
Verrà archiviata solo l'importazione.
Ora se assegni una variabile intera a una variabile in virgola mobile, che è l'opposto,
non causa alcun cambiamento nel valore del numero.
Il valore viene convertito dal sistema e memorizzato nella variabile mobile.
In modo che tu non debba davvero preoccuparti di assegnarlo a un flusso.
Se assegni 12 a un flusso, sarà ancora 12, solo 12. 0.
Quando esegui operazioni aritmetiche su interi e
quindi questo è diverso dall'assegnare valori assegnandoli in un float o float a int,
questo è quando hai un'espressione,
stai facendo un'addizione o una sottrazione, qualunque sia il caso.
Quando esegui una sottrazione o un'addizione, hai due operandi.
Quindi un operatore può essere un int, un operando può essere un float.
Devi sapere come sta avvenendo la conversione.
Quindi, se hai due operandi in un'espressione e sono entrambi
numeri interi, qualsiasi parte decimale risultante da un'operazione di divisione viene scartata.
Quindi se lo fai se hai un numero intero x, è 20.
Hai un intero y, è 12. E fai 20 diviso per 12.
Non otterrai 1 punto qualcosa qualcosa qualcosa. Otterrai solo 1.
Scarterà tutti i risultati e ne aggiungerà uno nuovo perché ancora una volta un int memorizza solo un numero intero.
Quindi due numeri sono int e stanno facendo la divisione.
Non otterrai un numero in virgola mobile. Non otterrai un numero decimale.
Ora, se un operatore è un int e l'altro è un float, l'operazione
verrà formata come un'operazione in virgola mobile. Quindi se hai float f è 20. 0, float a è 10,
an int, quindi se fai una divisione
lì o 12 mi dispiace che sarebbe più applicabile, il risultato
sarà un numero in virgola mobile e il risultato
sarà 1 punto 8888 o qualunque cosa sia 1 punto qualunque
sia il caso.
Non stai assegnando questi dati a nulla. Questa è un'espressione che cosa tornerà.
Quindi due int in una divisione, sarà un numero intero.
Un int e double o float, sarà sempre un float, sarà sempre un'operazione
in virgola mobile decimale decimale.
E questa è la conversione implicita. Questo è davvero ciò di cui hai bisogno
per capire cosa sta succedendo e cosa fa per te dal programma se non fai nulla.
Tuttavia, dovresti provare a fare
alcune conversioni esplicite, che puoi fare con l'operatore cast.
E questo è solo indicato come casting più o meno.
E vedi la trasmissione in molte lingue quando vuoi convertire.
E tutto ciò che stai facendo una conversione
esplicita, stai dicendo cosa vuoi che siano i dati.
Quindi vuoi farlo se puoi, perché altrimenti
i dati potrebbero essere degradati, potrebbero andare persi.
Se fai due int e stai facendo la
divisione e non sono divisi equamente, perderai tutti quei dati.
Quindi è possibile richiedere la conversione del tipo precisa
che desideri specificandola esplicitamente.
Questo è chiamato cast e consiste nel far precedere la
quantità con il nome del tipo desiderato tra parentesi.
Quindi le parentesi e
il nome del tipo costituiscono
l'operatore cap.
Fai una parentesi sinistra e poi specifichi il tipo di dati e poi scrivi le parentesi.
E questo convertirà tutto ciò che è alla sua
destra, qualunque sia l'espressione alla sua destra o anche se è solo una singola
variabile, la convertirà in ciò che è sempre tra parentesi.
Quindi il tipo effettivo è desiderato come un lungo, è sostituito da quel tipo di parola.
Quindi l'operatore di tipo passato ha una precedenza maggiore di tutti gli operatori aritmetici tranne il
meno unitario e l'unità più. Non abbiamo ancora imparato a conoscere la precedenza.
Lo vedremo nella prossima lezione. La precedenza è fondamentalmente ciò
che accade, l'ordine delle operazioni che vengono eseguite.
Quindi forniremo alcuni esempi di questo. Tutto quello che devi capire a questo punto è
che l'operatore typecast ha la precedenza su ogni altro operatore, ad eccezione di due meno unari e più unari.
Quindi qui esempio, abbiamo un numero 21. 51 e abbiamo l'operatore
cast perché sappiamo che è operatore cast perché è tra
parentesi e ha un tipo. E quello che stiamo dicendo in pratica
è prendere 21. 51 convertirlo in un int.
Se si prende un numero in virgola mobile
convertito in esso, diventa solo l'int, il numero intero, 21.
Lo stesso che sta facendo sul lato destro, sta convertendo 26. 99 a un int.
Quindi cosa succederebbe effettivamente qui se facessi questa espressione in un'affermazione, verrebbe
valutata come 21 più 26. Troncerebbe i dati
da 0. 51 a un numero intero e uguale a 0. 99.
E quindi questo è l'operatore cast, qualsiasi cosa racchiusa tra parentesi che contenga un tipo di dati.
Lo vedrai spesso.
Se dovessi dire 21 più 26 e lo lanci in float, aggiungerebbe
semplicemente un punto 0.
Di solito, non lanci su un tipo più preciso perché
non diventerai più preciso.
Lanci da un tipo più preciso a uno meno preciso.
Quindi più simile a un float a un int.
Quindi lo vedrai occasionalmente in alcuni programmi quando
usi tipi diversi. Dovresti cercare di evitare di usare tipi
diversi se stai facendo aritmetica. Ma se lo fai, vedrai questo.
La dimensione dell'operatore, un altro operatore un po 'strano,
non simile a molti degli altri. E questo in realtà sembra una funzione.
Ma la dimensione di è un operatore. Esegue un'azione.
Non sta facendo nulla di orientato alla funzione.
Quello che sta facendo è dirti quanti byte sono occupati in memoria
da un dato tipo. Quindi sembra una funzione perché richiede un argomento.
E ne faremo un esempio ma restituirà solo il numero di byte in memoria. Ricorda che a seconda del
sistema che stai utilizzando, la piattaforma
che stai utilizzando, il sistema operativo, l'architettura del computer, l'hardware,
i diversi tipi di dati saranno rappresentati dalla memoria con dimensioni diverse.
Ad esempio, un int potrebbe essere di 4 byte su 1 sistema 8 in un altro.
Quindi quello che puoi fare è usare l'operatore sizeof come una parola chiave speciale un operatore in ce puoi
passare un tipo di dati e ti dirà quanti byte sta usando in memoria.
Quindi sizeof è in realtà un operatore, non è una funzione.
Viene valutato in fase di compilazione e non in fase di esecuzione a meno che non venga utilizzato un array di lunghezza variabile nel suo argomento.
E quindi ne parleremo. Questo fondamentalmente sta dicendo che se hai una
variabile che è all'interno della dimensione di
un array, non verrà risolta in fase di compilazione in fase di runtime, quindi non
è così importante saperlo.
L'argomento dell'operatore sizeof può essere una variabile, un nome di array, il
nome di un tipo di dati di base, come
int float, il nome di un tipo di dati derivato qualsiasi cosa o un'espressione.
Quindi potresti dire sizeof x plus y.
E questo fondamentalmente sta solo per dire la dimensione di
x più la dimensione di y oi numeri risultanti. Se x è un int, y è int e la sua dimensione è
16, direbbe che questo è un pollice 4 byte.
Se fosse int uno era un float e il risultato era un aritmetico in virgola mobile, allora
sarebbe float è di 8 byte o qualcosa del genere.
Ma puoi usarlo per molte cose e dovresti usarlo per molte cose. Sizeof int, ad esempio, risulterà nel
numero di byte occupati da una variabile di tipo int.
Quindi questo restituirà 4 o 8 a seconda del sistema.
Puoi anche applicare l'operatore sizeof a un'espressione, come ho detto, il
risultato è la dimensione del valore.
Ciò risulta dall'espressione dell'area. Quindi, se due int insieme, saranno ancora un int.
Quindi sarà ancora una taglia. Ma vedrai anche l'operatore sizeof utilizzato quando parliamo di puntatori.
Volevo parlarne adesso perché è un operatore.
Ma forniremo molti altri esempi di questo e casting durante la classe mentre
parliamo di più concetti.
Nello specifico, l'operatore sizeof entra in gioco molto di più
quando parliamo di puntatori perché quando
calcoli la quantità di memoria da allocare, che è ciò che sono i
puntatori, usi sizeof perché vuoi essere preciso.
Ma puoi usarlo anche per altre cose.
Quindi usa l'operatore sizeof quando possibile per evitare di avere un hard code per il calcolo delle
dimensioni nel tuo programma.
Dimensioni hard code numeri magici non sono una buona cosa perché di nuovo
se sei su un sistema diverso, se dovessi codificare 4 su
1 sistema per un int, sull'altro sistema potrebbe essere un 8, quindi usa
sizeof tanto quanto puoi e vedremo che questo diventa molto più facilmente
riconoscibile quando parliamo di indicatori.
Altri operatori un
po 'strani sono l'operatore asterisco.
Potresti aver detto a te stesso asterisco, ne abbiamo già parlato moltiplicando.
Ma quell'asterisco accetta due operandi, uno a sinistra e uno a destra.
Se applichi l'operatore asterisco a una
variabile e dici semplicemente nome variabile stella con un solo argomento
a destra, rappresenta qualcos'altro. In realtà rappresenta un puntatore.
Sta dereferenziando un puntatore.
E ancora, questo è che non ho intenzione di insistere su questo ora perché
lo affronteremo quando parliamo di indicazioni.
Ma se vedi qualcosa come la stella a, non spaventarti, è effettivamente valido.
Questo sta facendo l'asterisco l'operatore del puntatore.
Potresti anche vedere il punto interrogativo dei due punti.
Questo è un operatore utilizzato per il processo decisionale.
Se la condizione è vera, se la cosa a sinistra è vera, viene
valutato il valore a destra dopo i due punti e così via.
È una notazione abbreviata per un'istruzione if-else.
È un operatore ternario, si chiama. Ma ancora una volta, non
voglio discuterne molto in dettaglio
ora perché ne parleremo quando parleremo dei nostri
argomenti specifici.
Parleremo dell'operatore di svolta quando parliamo di dichiarazioni di decisione. Parleremo dell'operatore
asterisco unario quando parliamo di puntatori.
Ma se lo vedi adesso e volevo menzionarlo ora perché sono tecnicamente operatori, ma capiremo i
loro casi d'uso quando parliamo di quei concetti. Grazie.