Ciao e bentornato.
In questa lezione, voglio parlare della definizione dei puntatori, principalmente la sintassi
per dichiarare reporter e quindi utilizzare l'indirizzo dell'operatore per assegnare un
indirizzo di memoria a un puntatore.
Quindi, fino a questo punto, dovremmo farci capire che un
puntatore non è altro che una variabile che
punta a un indirizzo di memoria o contiene un indirizzo di memoria come suo valore.
Quindi dichiarare un puntatore non è la stessa cosa che creare un normale puntatore.
Quindi non puoi fare qualcosa come il puntatore del puntatore.
Non è questo il modo per dichiarare un puntatore. La sintassi è leggermente diversa.
Usi un asterisco. Quindi non è sufficiente dire che una variabile è un puntatore.
Devi anche specificare il tipo di variabile a cui punta il puntatore.
Diversi tipi di variabili occupano diverse quantità di spazio di archiviazione.
Alcune operazioni del puntatore richiedono la conoscenza di quella dimensione di archiviazione.
Quindi, proprio come una variabile normale quando specifichi un tipo di dati,
quando crei una variabile di un tipo di dati del
puntatore, devi anche specificare quel tipo di dati.
È possibile dichiarare un puntatore a una variabile di tipo int facendo quanto
segue, int star o asterisco p number.
Questo ti dirà che è un puntatore.
L'int sembra lo stesso, ma dopo c'è l'asterisco.
L'asterisco indica che un puntatore e quindi si specifica il
tipo di puntatore stesso. Questo è un puntatore int.
Il tipo di variabile con il nome p numbers int star.
Può memorizzare l'indirizzo di qualsiasi variabile di tipo int.
Un puntatore memorizza gli indirizzi. Quindi, se hai
intenzione di memorizzare l'indirizzo di un'altra variabile, quella variabile
deve essere definita come un tipo intero.
Quindi qui PI punta a una
variabile int,
char star pc, che punta a una variabile carattere,
float star pf star pg, questi sono puntatori a variabili float.
È così che li definisci, i tipi contano.
Lo spazio tra l'asterisco e il nome del puntatore è facoltativo.
Non devi mettere uno spazio lì. Non puoi avere spazio.
Quello che finisce per
accadere, e parleremo della dereferenziazione di una variabile è che di solito usi uno spazio nella dichiarazione
e poi quando stai dereferenziando non lo usi.
Quindi tutte queste dichiarazioni dovrebbero contenere uno spazio per convenzione.
Il valore di un puntatore è
un indirizzo, quindi deve essere rappresentato internamente come un'immagine senza segno sulla maggior parte dei sistemi.
Quindi deve ancora memorizzare qualcosa. Accade così che memorizzi un numero esadecimale.
E anche se lo sta memorizzando come se fosse un numero
intero, non pensarlo come un tipo intero.
Le stesse cose che puoi fare con i numeri interi, non puoi necessariamente farlo con i puntatori e viceversa.
Quindi, anche se provi a stamparlo, sembrerà un numero un numero esadecimale, non significa che
puoi trattarlo come un numero intero.
Puoi moltiplicare un numero intero per un altro, ad
esempio, ma non puoi moltiplicare un puntatore per un altro.
Un puntatore è davvero un nuovo tipo, non è un tipo intero.
La percentuale p rappresenta il formato specificato per i puntatori.
Passerò attraverso la visualizzazione dei diversi dati per un puntatore e vedremo come viene utilizzato.
Le dichiarazioni precedenti creano
la variabile ma non c'è inizializzazione. Non ci sono incarichi lì.
Se si desidera sempre assegnare un
valore a un puntatore, è molto pericoloso se non lo si inizializza.
Quindi vuoi inizializzare un puntatore quando lo dichiari.
Se non sai cosa inizializzare se
non è l'indirizzo di un'altra variabile o
non hai allocato la memoria dinamicamente per essa, puoi usare un puntatore nullo.
Quindi puoi inizializzare un puntatore in modo che non punti a nulla.
Puoi farlo usando null.
Dici che instar p number è uguale a null per un puntatore a un int.
Null è una costante definita dalla libreria standard.
È l'equivalente di uno zero per un puntatore.
Significa che non punta a nulla.
È garantito che non punti a nessuna posizione nella memoria.
Quindi è bene che tu voglia farlo perché significa che non
commetterai errori eseguendo accidentalmente un buffer overflow o scrivendo in
memoria su cui non dovresti scrivere.
Inizializzandolo a questo, in realtà limita alcuni errori che puoi fare.
Abbiamo parlato di null un po 'in precedenza. Abbiamo parlato del carattere nullo.
Questo concetto è diverso dal puntatore nullo.
Un puntatore nullo significa che non punta a nulla e dovrebbe essere inizializzato con quello.
È necessario aggiungere una direttiva include per la definizione standard. h se vuoi usare la
definizione nulla qui.
L'indirizzo dell'operatore. Se si desidera assegnare il puntatore
a un indirizzo,
è possibile utilizzare l'operatore indirizzo di una variabile esistente.
Quindi, se vuoi inizializzare la tua variabile con la variabile add o sub
che hai già dichiarato di utilizzare l'indirizzo dell'operatore, la e commerciale.
Lo abbiamo visto quando abbiamo discusso della funzione scanf.
Qui stiamo assegnando una variabile di valore intero 99.
Stiamo creando un puntatore di tipo int e gli stiamo assegnando l'indirizzo di numero.
Possiamo farlo perché numero è un int
e anche il puntatore che abbiamo creato punta a un int.
Quindi tutto ciò che dobbiamo fare dopo l'operatore uguale è usare la e commerciale.
E così ora p numero conterrà l'indirizzo del numero.
Il valore iniziale di p numero è l'indirizzo del numero variabile.
La dichiarazione di numero deve precedere la dichiarazione del puntatore che memorizza
il suo indirizzo perché
non è possibile assegnare a un puntatore qualcosa
che non ha memoria allocata.
Se provi ad assegnare a quel numero di puntatore, il numero non esiste a meno che non lo fai dopo.
Per assegnare un indirizzo a un
puntatore, a quell'indirizzo deve essere allocata memoria.
Altrimenti, il compilatore si lamenterà.
Attenzione però perché non c'è niente di speciale nella dichiarazione di un puntatore.
È possibile dichiarare variabili e puntatori regolari nella stessa istruzione.
Quindi potresti dire doppio valore, valore p f num.
In questa dichiarazione qui, questa è l'unica
la seconda variabile p val è un puntatore, le altre due sono solo doppie.
Questo è un po 'più esplicito, un po' più
ovvio in quella dichiarazione. Ma cosa succede se dici in
star pq, questo implica che sono entrambi indicatori e non lo sono.
Abbiamo solo un puntatore int qui che è p, la
variabile q serve solo per digitare int.
È un errore comune pensare che sia p che q siano puntatori.
Quindi fai attenzione quando dichiari un puntatore su molte variabili sulla stessa riga.
È anche una buona idea usare nomi che iniziano con p come nomi di puntatori.
Questo ti dirà che quella variabile è un puntatore semplicemente guardandola.
Quindi di solito fai tutte le tue dichiarazioni di variabili all'inizio di
un programma, di solito all'interno della funzione principale.
E quando vedi quelle variabili usate successivamente
nel programma, puoi facilmente identificare i diversi tipi di dati
oi diversi tipi di puntatore perché hanno p come prefisso.
Quindi questa lezione ha appena
spiegato come definire, dichiarare un puntatore e quindi assegnare un indirizzo
di una variabile esistente a un puntatore.
Ora ci sono casi in cui non vuoi necessariamente
assegnare a una variabile esistente un valore di puntatore, forse vuoi allocare nuova memoria.
Ne parleremo nella lezione successiva. Ma in questo momento, lo manterremo semplice.
Ci concentreremo sull'uso di puntatori di tipo
int e diversi tipi facili come double o float.
E ci concentreremo sull'assegnazione delle
variabili esistenti, l'indirizzo di e vedremo come funziona.
Quindi andiamo avanti. Grazie.