Ciao e bentornato.
Vorrei fornire una soluzione a sfida precedente in questa conferenza.
Una dimostrazione di come tu può avere puntatori come elementi all'interno della
struttura e anche passare i puntatori a due funzioni
che sono strutture.
Quindi portiamo in primo piano il codice blocchi, crea un nuovo progetto.
Questa sarà una console application, e chiameremo questo
esempio di puntatori di struttura.
E quindi se ti ricordi per il file requisiti
per questo, questo era fondamentalmente solo un tipo di prodotto struttura che memorizzava il nome di un articolo, una
quantità, un prezzo e un importo.
E il nome dell'oggetto stava andando essere un puntatore di caratteri.
Stavi per avere un file importo che in pratica ha moltiplicato solo
la quantità nel prezzo.
E poi abbiamo avuto due funzioni che prenderà come parametri i
puntatori a una struttura.
Quindi la prima cosa che siamo faremo
è creare la nostra struttura.
E ne ho parlato prima, ma è bene creare
la struttura a livello globale perché se lo desideri usalo in più funzioni.
Creazione della struttura lo sta davvero definendo.
Non stai allocando alcuna memoria.
Quindi non c'è niente di male mettendolo a livello globale.
E di solito vanno dentro comunque il file di intestazione.
Quindi per creare una struttura, diciamo solo struct.
Chiameremo questo elemento e avremo quattro elementi.
Avremo un personaggio pointer, che chiameremo semplicemente
nome dell'elemento.
Avremo una quantità.
Avremo un galleggiante per il prezzo e avremo
un galleggiante per l'importo.
Ed è così che possiamo definire la nostra struttura, piuttosto semplice.
Ora all'interno della nostra funzione principale, noi desidera creare una variabile per il tipo di struttura e
anche un puntatore.
Quindi la prima cosa che vogliamo fare è vogliamo solo dire struct item con
il nome della struttura e quindi chiameremo semplicemente questo elemento.
E questo è giusto creando un puntatore dispari.
Questo allocherà la memoria per le quattro variabili ed elementi
all'interno della struttura.
E quindi vogliamo creare il nostro puntatore ora, e possiamo semplicemente dire struct item.
Diremo p item perché di solito chiamiamo i nostri
puntatori con il prefisso p.
Quindi diciamo l'asterisco, e diciamo p item.
E poi nella riga successiva,
vogliamo solo assegnare al nostro elemento puntatore, il nostro elemento.
Quindi dobbiamo usare il file indirizzo di e diciamo oggetto.
E così qui abbiamo la memoria assegnato per elementi nella nostra struttura per il
nostro puntatore.
Non abbiamo memoria assegnato per il nostro puntatore di caratteri
che è il nome del nostro oggetto, quindi quello sarebbe il passo successivo.
Ora potresti chiedere perché ne abbiamo bisogno per creare la struttura dell'oggetto.
Non lo facciamo davvero.
Potremmo semplicemente creare il puntatore e il puntatore creerà memoria solo per
quel puntatore all'elemento struct.
Allocherà memoria per il file int e
floats, ma dobbiamo ancora eseguire l'allocazione del nome dell'elemento.
Mi piace farlo perché di solito questa è la buona pratica.
Tipicamente cosa faresti con la struttura del primo elemento è che dovresti
inizializzare, e così tu avrebbe qualche inizializzazione.
Ma non abbiamo bisogno di farlo.
Quindi la prima cosa che vogliamo fare è allocare memoria per il nome del nostro articolo.
Quindi possiamo fondamentalmente usare un file operatore speciale per accedere agli elementi se si tratta
di un puntatore.
Ricorda, per le strutture che sono puntatori, hai il trattino quindi maggiore del
simbolo che hai può usare per accedere agli elementi.
Altrimenti, dovresti de-referenziare il puntatore per accedere agli elementi.
Potremmo fare qualcosa di simile questo tra parentesi.
Potremmo de-referenziare il puntatore, quindi dovremmo
fare qualcosa come star p item e poi usare il punto per accedere agli elementi.
Questo è perfettamente valido fare qualcosa di simile.
Ma è una specie di sintassi extra di cui non hai veramente bisogno.
Quindi c ha una sintassi speciale che puoi usare ogni volta che la tua struttura
è un puntatore se tu desidera accedere agli elementi.
In pratica puoi solo dire il nome del puntatore che è l'elemento p e quindi utilizzare
il trattino quindi maggiore di.
E in questo caso, lo vogliamo allocare memoria per il nome dell'elemento.
Quindi assegneremo ciò che è restituito dalla funzione malloc.
Ricorda, la funzione malloc restituisce un puntatore vuoto.
Quindi dobbiamo lanciarlo a una star del personaggio.
Ma possiamo solo chiamare malloc, solo diciamo malloc e poi la dimensione dei
byte che vogliamo creare.
In questo caso, diremo solo 30, e lo moltiplicheremo per la dimensione di char, nel
caso in cui char sia un dimensioni diverse su computer diversi.
E questo sta per allocare memoria per il nome del nostro articolo.
Dobbiamo farlo perché il nome dell'oggetto è un puntatore all'interno della struttura.
Non ha memoria assegnato quando lo
si assegna a un'altra struttura.
Quindi dobbiamo farlo.
Ora la prima cosa che vuoi da fare
dopo aver allocato la memoria è controllare il file malloc.
quindi vogliamo verificare la presenza di null qui.
Diremo solo if p item, if è nullo che direbbe che è nullo.
Altrimenti, diresti che se no, potresti dire semplicemente return o exit sarebbe probabilmente meglio, uscire dal programma se
noi non sei stato in grado di allocare memoria e potresti
passarla in negativo.
Altrimenti, vogliamo leggere in un file elemento, quindi vogliamo creare una funzione.
La funzione che stiamo andando per creare si chiama elemento di lettura.
Mettiamo una dichiarazione di funzione quassù sopra la struttura.
Leggerà solo i dati nella struttura che gli abbiamo passato.
Non restituirà alcun dato.
Quindi possiamo solo dire leggere elemento e ci vuole una struttura, e questo sarà un
puntatore.
Quindi è un elemento struct, asterisco I.
Ora potremmo renderlo una costante quindi i valori cambiano, ma
noi stiamo cambiando i valori.
Ma potremmo dire struct costante, il i valori non sarebbero in grado di cambiare
per quel puntatore a cui punta.
Se abbiamo fatto la costante dopo l'asterisco, che direbbe che l'indirizzo non può essere modificato
o corretto prima dell'asterisco qualcosa del genere dopo
il nome.
Ciò direbbe che l'indirizzo non può cambiare, ma
è ridondante perché stiamo passando per valore di copia.
Abbiamo il nostro articolo letto.
E mentre sono qui potrei così come il mio articolo di stampa.
Questa sarà solo la funzione dichiarazione, prototipo di funzione.
Qui sarà molto simile, prendi anche un puntatore.
Può avere uno spazio se vuoi dopo l'asterisco o no?
Ora possiamo definire la nostra lettura articolo sotto il nostro metodo principale.
E questo leggerà nei valori dell'articolo e quindi
calcolare l'importo totale.
Quindi possiamo dire void read oggetto, avere il nostro puntatore.
E qui dentro, vogliamo solo per usare davvero alcuni scanfs.
Stamperemo alcuni messaggi per dire all'utente di inserire le informazioni.
Quindi diremo entra nome del prodotto e poi lo leggeremo.
Quindi diremo scanf, e abbiamo un puntatore a una struttura, quindi possiamo accedervi
utilizzando il trattino quindi maggiore di.
Vogliamo leggere per scanf, il file il nome del prodotto è un buffer di caratteri.
Quindi vogliamo dire percent s e quindi diremo io, lo memorizzeremo
nel nome dell'oggetto.
E potremmo tornare indietro e utilizzare il file intellisense basta andare al nome dell'elemento.
Non dobbiamo usare il file indirizzo dell'operatore perché è
un puntatore a carattere.
Quindi vogliamo stampare e ottenere il prezzo,
probabilmente vuoi aggiungere alcuni feed di riga qui, inserisci il prezzo.
Stiamo andando a memorizzare quello nella struttura.
Quindi, ancora una volta, il prezzo è un galleggiante.
Quindi dirò percento f, ma accediamo anche perché è un puntatore, lo vogliamo ancora usa
il trattino quindi maggiore di.
Tranne che questa volta, lo faremo diciamo prezzo, e dobbiamo ottenere l'indirizzo, quindi lo faremo metti
una e commerciale davanti perché il prezzo non
è un indicatore.
E poi faremo il file stessa cosa per la quantità.
Quindi la quantità è un numero intero.
Quindi possiamo dire percento d, abbiamo ancora bisogno per ottenere
l'indirizzo, ma vogliamo memorizzarlo in un elemento diverso, vogliamo memorizzarlo nella quantità.
Ora che abbiamo archiviato o chiesto l'utente di inserire
tre elementi di informazioni, ora possiamo calcolare effettivamente l'importo, memorizzato
qualcosa nell'importo.
L'importo è solo il quantità moltiplicata per il prezzo.
Quindi vogliamo ancora accedere al file struttura usando la nostra sintassi, vogliamo
lanciarla, vogliamo firmare la quantità moltiplicata per il prezzo.
E questa è la funzione di lettura dell'elemento.
Accetta un puntatore di struttura.
E così quando modifichiamo questo puntatore all'interno dell'elemento letto, verrà modificato
al di fuori della funzione.
Quindi qualunque sia la nostra struttura passare a questa funzione,
verrà modificato.
Memorizzerà tutti i file articoli, il nome dell'articolo, il prezzo e
la quantità e l'importo.
Quindi questo legge i dati.
A questo punto, vorresti farlo test e probabilmente vorrai compilare
e testare prima di questo.
Ma ora possiamo chiamare l'elemento letto metodo nel nostro main e passarlo nella
nostra struttura che abbiamo creato.
Quindi possiamo dire leggi elemento, e possiamo solo dire p item.
Non dobbiamo passare in address perché è un puntatore, quindi
passiamo semplicemente alla nostra struttura.
E poi la prossima cosa noi possiamo fare è stamparlo.
E ciò che questo ti mostrerà è che i dati vengono salvati, l'elemento p
viene modificato all'interno della funzione e viene salvato al di fuori della funzione, la
funzione principale ha effettivamente salvato quei valori.
Quindi possiamo dire che l'elemento di stampa passa di nuovo nel puntatore, quindi possiamo definire la funzione di
elemento di stampa.
L'elemento di stampa è piuttosto semplice.
Non restituisce niente quindi diciamo void e diciamo
print item richiede un puntatore.
Quindi diciamo solo struct item star Io, qualunque cosa tu voglia chiamarlo.
E poi stampiamo solo i dati per la struttura che è stata ceduta.
Quindi faremmo qualcosa di simile printf name percent s, I item name, I price,
I quantity and I importo e quindi formattare i dati.
Qual è l'ultima cosa che abbiamo
da fare principalmente dopo aver stampato i dati, il file funzione gratuita davvero importante.
Dobbiamo chiamare gratis perché noi desidera liberare la memoria che abbiamo allocato
per il nome dell'elemento.
Quindi possiamo solo dire elemento p gratuito e quindi accedi al nome dell'elemento.
Non vogliamo liberare l'intero struttura perché
l'intera struttura verrà eliminata nel file stack quando la funzione ritorna.
Vogliamo solo liberare ciò che abbiamo ottenuto.
Abbiamo mallocato solo per articolo nome così lo liberiamo, e poi
torniamo dal main.
Quindi andiamo avanti e prova a costruire questo.
E abbiamo un errore.
Vediamo che dice struct item star.
Quindi abbiamo avuto un errore dove le funzioni sono state definite sopra
la struttura.
Ma la funzione di prendere un file parametro come tipo di struttura.
Quindi dobbiamo avere la struttura definito sopra dove lo stiamo usando.
Quindi sposto le funzioni fino alle righe 12 e 13.
Ora siamo in grado di compilare.
Andiamo avanti ed eseguiamo questo.
E vediamo cosa otteniamo qui.
Abbiamo ancora un errore.
Devi essere sicuro di te controllare l'elemento p per null.
Se dici solo if p item per vero, sarà sempre vero.
Quindi puoi controllare per dire non è vero con il simbolo
not che significa che non è nullo o tu può verificare se è nullo.
Quindi ho appena aggiunto il null lì.
Quindi ora lo eseguiamo, noi dovrebbe essere a posto.
Possiamo inserire il nome del prodotto.
Diremo seriale e lo faremo diciamo che il prezzo è 1. 99.
E diremo che ne abbiamo cinque.
E ora lo stampiamo, e diciamo dollaro seriale 99.
5, l'importo totale è 9. 95.
Il prezzo però non mi piace come viene stampato il prezzo.
Quindi aggiustiamolo.
Nel nostro articolo di stampa, possiamo solo dire per prezzo dor 2 f float, ora
avremo un aspetto un po 'migliore, e lo eseguiamo.
Otterremo un po ' un po 'di formato migliore.
Quattro di loro e ora sembra un po 'meglio ed
è tutto a posto.
Quindi, di nuovo, il programma di base utilizzando strutture e puntatori.
Abbiamo creato la struttura in alto.
Abbiamo un membro che contiene un puntatore, è molto
efficiente farlo perché possiamo solo copia e indirizzi invece di
array di caratteri.
Abbiamo le nostre due dichiarazioni func, elemento di lettura elemento di stampa
che accetta i puntatori distrugge.
E poi creiamo il puntatore e assegnarlo a una struttura regolare
all'interno del nostro main.
Allochiamo memoria sulla riga 22.
Ci assicuriamo che la memoria sia allocato con successo se non lo
fosse, usciamo dal programma.
E poi chiamiamo i nostri due funzioni che prendono
puntatori a strutture, li passano.
E poi, ultimo ma non meno importante, liberiamo la memoria e poi
usciamo dal programma.
E le funzioni lo sono abbastanza diretto.
Prendi quel puntatore.
Si accede al puntatore utilizzando il trattino quindi maggiore di.
E ottieni l'indirizzo di per scanfs che non hanno
puntatori come elementi.
E questo è fondamentalmente tutto.
Salverò questo programma, dai un'occhiata.
Fatemi sapere se avete domande. Grazie.