Ciao e bentornato.
Poiché l'aritmetica dei punti è un concetto difficile da capire e
afferrare, volevo passare attraverso un ultimo
esempio che dimostra davvero questo concetto, fa un buon lavoro.
E se comprendi questo esempio, non avrai
problemi con l'aritmetica dei punti.
Quindi il primo esempio che voglio mostrarti è l'effetto
dell'aggiunta di un valore intero a un puntatore.
Quindi, quando eseguiamo l'aritmetica dei puntatori con addizione,
possiamo effettivamente vedere come funziona in termini di indirizzi.
Quindi qui in questo programma, tutto ciò che sto facendo è creare una
stringa, un array di caratteri, si chiama stringa.
E poi creo un puntatore a carattere chiamato p.
Sto esaminando tutta la lunghezza della stringa che è
multipla. Quindi sto esaminando l'intero array.
Basta nominare base per la lunghezza della forza dei loop di dimensioni multiple e multiple.
E poi stampo ogni stringa
o carattere effettivo all'interno di quell'array.
E anche quello che sto facendo è visualizzare
l'indirizzo e
quindi l'indirizzo con il numero effettivo che ho aggiunto.
Quindi diamo un'occhiata solo all'output di questo perché l'output
mostra un ottimo esempio di aritmetica dei punti.
Quindi andiamo ai blocchi di codice ed eseguiamo questo.
Quindi eccoci nei blocchi di codice. Ho ripulito un po 'il codice.
Uso str length, imposta una lunghezza strn perché è extra include.
E voglio solo eseguire questo.
Quindi, quando lo eseguo, quello che noterai è che ti mostra
come ricordare come appare la memoria e ti mostra i valori che
fanno l'aritmetica dei punti. Quindi, se dici più
sotto-0, ricorda, multiplo contiene solo una stringa.
Ma se guardiamo questo e diciamo guarda il contenuto dell'array, i
multipli di 0 sono a, i multipli di 1 sono uno spazio e quindi il resto sono stringhe.
Questo è l'array.
Proprio accanto a questo è lo stesso che aggiungere 0 al
puntatore e dereferenziarlo, aggiungere 1 e aggiungere 2.
E ti mostra come puoi fare l'aritmetica del puntatore dereferenziando il
puntatore stesso e aggiungendo numeri ad esso.
Quindi il puntatore più sette dereferenziazione che ottieni g.
Quindi, nella terza colonna, ti mostro gli indirizzi
effettivi man mano che aumentiamo. Quindi gli indirizzi di
ogni elemento nell'array usando la e commerciale solo sull'array
di caratteri, vediamo l'indirizzo 060feff per l'elemento 0 e così via.
E poi guardiamo gli indirizzi se
aggiungiamo al puntatore stesso senza dereferenziarlo, e
vedrai gli indirizzi allineati.
Quindi possiamo guardare la sintassi per vedere cosa sta succedendo qui in termini
di prima cosa che effettivamente mostriamo è l'indice nell'array che è solo un contatore.
Quindi visualizziamo una percentuale c che è
il carattere nell'array.
La prossima cosa che stiamo visualizzando è
la dereferenziazione del puntatore più I.
Quindi qui quello che stiamo facendo è visualizzare I e
quindi visualizzare la dereferenziazione del puntatore più I, il
valore effettivo.
Quindi
mostriamo come d
solo il contatore effettivo e quindi il punto c
è il nostro dereferencing. Quindi p è il nostro puntatore.
Stiamo solo dicendo p più I, aritmetica del puntatore, e
poi lo dereferenziamo.
Quindi, per ottenere gli indirizzi,
tutto ciò che dobbiamo fare per ottenere l'indirizzo dell'array è
dire e commerciale multiplo e quindi l'indice.
Per ottenere per primo l'indirizzo del puntatore qui diciamo solo p
più I
per ottenere il contatore effettivo
che ti mostra come stiamo incrementando quella p,
facciamo solo una p più la percentuale d.
Ma fa un buon lavoro nel
dimostrare i vari modi in cui la memoria a
cui stiamo puntando agli
indirizzi viene effettivamente visualizzata e come sono
equivalenti ai diversi indici in un array e ai puntatori effettivi.
Ho pensato che questo facesse un buon lavoro.
Voglio vedere un altro esempio che fa un altro buon lavoro
riguardo all'aritmetica dei puntatori con i lunghi. Perché qui questi sono
numeri interi. Quindi tutto ciò che dobbiamo fare è
aggiungerne uno e passare automaticamente al byte successivo e così via. Diamo un'occhiata a quello che facciamo, facciamo i desideri.
Quindi, in questo esempio, volevo anche solo dimostrare come puoi fare la stessa cosa
con un puntatore lungo e uno lungo.
Con il puntatore a caratteri, era solo un array di caratteri stringa.
Ma anche per array lunghi, che sono di dimensioni
diverse, possiamo ancora iterarli usando un puntatore e
puoi vedere come cambia effettivamente il numero di byte.
Quindi, anche se diciamo di avere un puntatore lungo e ne aggiungiamo uno, in realtà stiamo aggiungendo
4 byte perché un lungo è un po 'più grande e lo vedremo in questo esempio.
Quindi ora eseguiamo questo esempio in blocchi di codice.
Quindi ecco il nostro esempio. Di nuovo, abbiamo un contatore intero, un contatore di loop.
Abbiamo un array lungo 15l.
Stiamo specificando l inserendo il suffisso, quindi specifichiamo i loro i,
i loro long abbiamo un puntatore lungo che punta a multipli.
Ancora una volta, poiché è un array, non è necessario utilizzare l'indirizzo dell'operatore.
Andremo per tutto il lungo. Qui non possiamo usare la lunghezza di mescolamento
di cui dobbiamo usare la dimensione, e in realtà dobbiamo dividerla per ogni punto dell'array.
Quindi la dimensione totale divisa per il singolo punto nell'array, è
allora che vogliamo saltare fuori perché
questi ricordano i nostri indirizzi che aumentano di 4 byte ciascuno.
E ancora quello che stiamo facendo qui è che stiamo solo
visualizzando sia il puntatore che l'array e mostrandoti come sono
correlati e quindi mostriamo il numero totale effettivo di
byte che il long è sul nostro sistema.
E quindi questo dimostra ancora una volta come gli array
sono correlati ai puntatori.
Quindi, se eseguiamo
questo, vedremo un output simile. Ma ciò che è leggermente diverso qui
è la dimensione dell'indirizzo, che sale di 4 byte. Quindi stamperemo l'indirizzo e il puntatore.
Quindi per l'indirizzo e il puntatore
più 0, sarà uguale
all'array sub 0 che è l'indirizzo 6356728.
E per dereferenziare il puntatore, otterremo il valore di 15.
Quindi p più 0 sarà ancora uguale all'array sub 0.
E poi di nuovo facciamo lo stesso per p più uno p
più 2 ep più 3, tutti equivalenti ai punti corretti nell'array per l'indice.
Gli indirizzi aumentano di 4 byte, ma possiamo ancora aggiungere solo 2 e 3 e vediamo
che i valori sono gli stessi.
E poi ci dice che questo lungo occupa 4 byte ed è per questo che gli indirizzi aumentano di 4.
Ciò che è significativo qui è che possiamo ancora aggiungerne
uno e il compilatore sa di andare all'indirizzo successivo.
Quindi, sia che abbiamo un carattere lungo o un carattere o qualunque
cosa quel particolare tipo di dati sia all'interno del sistema, aggiungendo
uno o 2 si aggiungerà il numero corretto di byte.
Quindi solo un altro esempio interessante che
volevo mostrarti perché questa aritmetica del puntatore è davvero importante ed
è davvero utile quando si itera
o si attraversa un array, rende molto più pulita e molto più efficiente.
Quindi spero che questo abbia aiutato. Grazie.