Ciao e bentornato. In questa conferenza, voglio fornire una
dimostrazione per
la nostra sfida precedente, che consisteva nel farti capire come
allocare la memoria in modo dinamico utilizzando malloc.
Faremo solo una semplice lettura dalla tastiera e poi
visualizzeremo una stringa, ma la useremo
con puntatori allocati dinamicamente, puntatori
a caratteri.
Quindi visualizziamo i blocchi di codice per creare un nuovo progetto.
E chiameremo solo questo esempio di allocazione dinamica della memoria.
E la prima cosa che devi
fare quando intendi utilizzare l'allocazione dinamica della memoria è assicurarti di includere la libreria standard.
Fortunatamente quando crei un progetto in blocchi di codice,
lo includerà automaticamente per te.
Ma il motivo per cui dobbiamo includere la libreria standard è perché malloc,
la funzione malloc è lì. E malloc, ricorda, è la funzione
principale per allocare la memoria. Hai anche calloc.
Calloc è molto importante perché calloc
farà alcuni dei bei calcoli di quanti byte ti
servono perché sono due parametri.
Ma la vera cosa buona di calloc è che inizializza tutti i dati
a zero se sono interi e così via, una funzione davvero carina.
Hai rialloc. Realloc estenderà la memoria che è
già stata allocata. Quindi lo passi in un puntatore.
Da quel puntatore, determina la quantità di memoria allocata per
esso e copia tutto ciò che era lì dentro in una nuova
posizione di memoria, quindi specifichi anche quanti byte
in più vuoi allocare aggiungendolo alla nuova posizione di memoria, davvero bella caratteristica.
Ma ricorda che quando stai allocando la memoria per interi usando
malloc, devi determinare quanta memoria vuoi allocare byte, ma di
solito vuoi usare l'operatore sizeof.
Quindi qui arriviamo a quello.
Nel mio metodo principale, creerò un numero intero e dirò solo
che sarà solo la dimensione. sta per inserire la dimensione del numero
di byte che vogliono allocare in fase di esecuzione, quindi memorizzerà la dimensione.
L'altra cosa che voglio creare è che voglio creare un puntatore a caratteri,
e questo sarà solo testo. E ho intenzione di
inizializzarlo su null perché non punta a nulla immediatamente.
La prima cosa che voglio fare è chiedere all'utente di inserire la dimensione.
Quindi dirò printf,
dirò inserisci limite del testo.
E inseriranno un numero per quanti byte vogliono essere allocati in realtà
è il numero di caratteri.
E poi lo leggerò usando scanf.
Scanf, il primo parametro è il tipo di identificatore di formato per il tipo di dati.
Sarà una percentuale d perché sto leggendo un numero intero.
E poi ricorda, scanf prende un puntatore.
Ora sappiamo che per le
funzioni che accettano puntatori è necessario un indirizzo da passare.
Quindi, se intendo passare la dimensione, la dimensione non è un indirizzo a meno che non utilizzi l'indirizzo dell'operatore.
Quindi vado a e commerciale e
dico size, che leggerà il numero di byte.
Una volta ottenuto il numero di byte, ora posso allocare memoria utilizzando la funzione malloc.
E malloc restituirà un puntatore vuoto.
E il puntatore sarà il primo indirizzo per
quella memoria appena allocata. Quindi puoi assegnarlo direttamente al testo.
Perché ricorda, il testo è un puntatore.
Vogliamo puntare il testo a questo nuovo indirizzo che viene restituito.
Poiché malloc restituisce un puntatore void, dobbiamo lanciarlo.
Il tipo di dati a cui stiamo puntando è un carattere, quindi vogliamo dire char
star, e quindi possiamo chiamare la funzione malloc.
La funzione malloc accetta il numero di byte.
E quindi il numero di byte, se hai appena passato il numero di byte, allocherà
solo quel numero di byte. Ma a seconda del tipo di dati,
il tipo di dati può essere di due o quattro byte.
Quindi, se vuoi allocare 10 caratteri,
assicurati di moltiplicare 10
caratteri per la dimensione del carattere.
Quindi ora
diremo n volte sizeof. L'operatore sizeof viene spesso utilizzato nella
funzione malloc perché è indipendente
dalla macchina e ti dirà quanto devi effettivamente allocare.
Ora questo è più rilevante quando hai numeri interi. Ricorda, i numeri interi, a seconda del
sistema in cui ti trovi, dell'architettura che stai utilizzando, i numeri
interi possono essere rappresentati da quattro byte, due byte, di solito
due o quattro byte.
Se dicessi che voglio memorizzare un intero, quindi
creerò solo quattro byte di memoria, beh, potrebbe non essere
corretto perché se fossero due byte.
Quindi vuoi sempre fare
quanti numeri interi o quanti caratteri vuoi creare e poi moltiplicarli per la
dimensione del carattere sul tuo sistema. L'operatore Sizeof ti darà il numero di
byte occupati da un carattere. Quindi, se vuoi creare 10 caratteri,
dici 10 volte la dimensione del carattere. Se vuoi creare 10 numeri
interi per memorizzare 10
interi, dici 10 volte la dimensione di int, questo è davvero importante.
Ora con la funzione calloc, non devi farlo. Calloc in
realtà accetta due parametri. E il primo parametro
è il puntatore, penso e quindi il
secondo parametro è la dimensione dei byte.
Quindi, se dici 24 int, tutto ciò che fai è passare solo
24 e allocare automaticamente per te.
Quindi calloc è uno strumento davvero carino da usare perché non devi fare questa moltiplicazione.
Quindi per calloc, il primo parametro è la dimensione.
Quindi, se volessi creare 10 int, dovresti semplicemente passare 10.
E poi il secondo parametro è
la dimensione del byte. Quindi non devi fare la moltiplicazione. Ti fa risparmiare un po 'di passaggio.
Ora che abbiamo allocato la memoria,
assicurati che il testo non sia nullo prima di provare a de-referenziare il testo.
Quindi vuoi sempre avvolgere questo attorno a un testo non, e questo dirà che
non è nullo o puoi semplicemente farlo esplicitamente e dire se il
testo non è uguale a nullo.
Voglio sempre farlo perché è molto, molto
pericoloso cercare di de-referenziare un puntatore.
Tutto può succedere. Potresti essere in grado di scrivere dati al suo interno.
dentro. Lo scriverebbe solo da qualche altra parte nella memoria. Quindi rovinerebbe
il tuo programma o potresti avere un errore di segmentazione e il programma potrebbe bloccarsi.
Ma fintanto che si alloca davvero quella memoria,
ora è possibile leggere effettivamente alcuni dati.
Puoi usare git s oppure puoi usare scanf qui.
Ma quello che vuoi fare
è stampare, inserire del testo e vogliamo
anche aggiungere dei feed di riga qui in modo che siano facili da leggere.
E useremo scanf poiché è quello che ci è familiare.
E scanf leggerà solo in
percentuale.
In realtà, ti mostrerò un trucco.
Userò scanf per leggere il carattere successivo in modo che
si fermi e poi userò get s per leggere nel testo.
E gets è solo un'altra funzione che di solito puoi usare f gets. Devi solo impostarlo per impostarlo sul
flusso di input.
Ma gets leggerà dal flusso di input standard, che per impostazione predefinita è la tastiera.
E prende sta per prendere un puntatore. Quindi tutto ciò che dobbiamo fare è passare
il testo perché è già un puntatore, non dobbiamo inserire l'indirizzo dell'operatore.
E la cosa bella di get ask è che puoi leggere in più stringhe separate da spazi.
Una volta che abbiamo effettivamente letto
get, possiamo semplicemente stamparlo. Quindi possiamo dire testo immesso se
immesso è una parola percentuale s barra rovesciata
ne quindi testo virgola. Il testo è un puntatore.
Printf prende un puntatore. Non dobbiamo de-referenziarlo.
Perché se visualizzi solo del testo,
il testo mostrerà il valore del puntatore che sarà un indirizzo.
Vogliamo effettivamente visualizzare il valore di ciò a cui punta il testo.
E poi abbiamo finito. Oh no, sicuramente non abbiamo finito. Vogliamo chiamare il nostro libero.
Vogliamo liberare il nostro puntatore.
Anche se quando usciamo, la memoria sarà libera. Vogliamo comunque assicurarci di liberarlo,
e quindi probabilmente vogliamo anche solo per sicurezza, vogliamo impostare il testo uguale a null.
Quindi andiamo avanti e costruiamo questo e vediamo cosa succede.
E ho un problema perché non sto leggendo nella
variabile giusta.
quindi qui non sto usando la variabile giusta. Voglio usare le dimensioni e
sembra
che stiamo bene.
Quindi qui andiamo l'unica differenza qui è che non devi de-referenziare il
testo perché il testo è un puntatore di carattere.
Devi solo de-referenziare se in pointer e così via. Quindi, solo quando usi
la percentuale s, automaticamente sa di de-referenziare il puntatore
del carattere.
Questa è una differenza quando usi i puntatori a
caratteri rispetto ad altri puntatori. Gli altri puntatori devi
de-referenziare per ottenere il valore perché non puoi effettivamente copiare
le stringhe negli array di stringhe e così via.
Non saresti mai in grado di fare la stella
del testo uguale, dovresti sempre usare la copia str se vuoi copiare il testo.
Poiché ricorda dalle lezioni, non puoi effettivamente assegnare
dati a un array e un puntatore a carattere è un array.
Quindi qui sembra corretto. Nessun motivo per de-referenziarlo.
Vogliamo costruirlo e poi eseguirlo.
E noterai che mettiamo il limite del testo.
Quindi diciamo di mettere 5, 6 per jason e
stampa l'input è jason.
E puoi giocare con questo programma. Ma ancora una volta, i
punti salienti di questo includono la libreria standard quando stai facendo malloc.
Inizializza i puntatori dei caratteri su null. Fai uno scanf, usa
la e commerciale perché la dimensione non è un puntatore.
Quando esegui il malloc, malloc restituisce un puntatore void, quindi devi eseguire il cast.
Vuoi sempre entrare nel tuo malloc. Eseguire l'operatore sizeof
per ciò che si desidera allocare. Volte, quanti caratteri effettivi sono
o numeri interi. Questo è più applicabile agli interi e
ai tipi di dati primitivi tecnicamente per i caratteri. Puoi solo fare le dimensioni, dovrebbe funzionare bene.
Vuoi sempre verificare la presenza di null, assicurati che non sia null.
Quando vai a usare la stringa di caratteri.
Quindi inseriamo del testo, memorizzato nei nostri file e lo stampiamo.
E poi, ultimo ma non meno importante, vogliamo sempre liberare i nostri puntatori in modo
da poterli restituire al mucchio. Spero questo sia di aiuto. Grazie.