Ciao e bentornato. L'ultima cosa di cui voglio parlare
riguardo alle strutture è come sono correlate alle funzioni, come
puoi passare le strutture come argomento a un parametro e una funzione e come
anche questo è più efficiente.
Quindi strutture come argomenti per le funzioni.
Dopo aver dichiarato una
struttura denominata Family. In questo esempio creeremo una famiglia
con nome, come passiamo questa struttura come argomento a una funzione.
Quindi abbiamo questa struttura chiamata Famiglia.
Abbiamo un sacco di matrici di
caratteri qui nome, padre e madre e poi abbiamo un'età int.
Questa è la nostra definizione di struttura.
Sappiamo che è una struttura perché la parola chiave struct è seguita dal nome del tag,
abbiamo le parentesi graffe e così via.
Ora come si passa effettivamente quella struttura a
una funzione chiamata fratelli?
Bene, lo faresti proprio come dichiari la struttura, diresti
il tipo come nome del parametro.
È davvero semplice. Quindi, in questo caso, abbiamo fratelli booleani.
Fratelli sta restituendo un valore booleano.
E sta prendendo due parametri, due parametri struct.
Devi identificare il tipo di struttura che è il tipo di famiglia di strutture.
Ora in c più avanzato, potresti effettivamente
fare un typedf su questa struttura e nominarlo qualcos'altro e potresti abbreviare il
nome qui, ma non abbiamo parlato di typed.
Probabilmente sarebbe meglio.
Ma questo è davvero il modo in cui avresti bisogno di farlo. Dovresti definire l'intero tipo, che è
struct family e quindi il nome della variabile, proprio come qualsiasi altro parametro.
Quindi qui stiamo passando due parametri, membro uno e membro due.
Sono entrambi di tipo struct family.
Quindi all'interno della nostra funzione, se vogliamo accedere ai membri, accediamo ai
membri come al solito.
Membro uno e membro due, non sono puntatori quindi non usiamo il trattino quindi maggiore di,
lo facciamo solo sui puntatori perché dobbiamo de-referenziarli per vedere a cosa stanno puntando.
Perché non sono puntatori, possiamo solo fare un punto. Quindi membro un punto madre, membro due punti madre.
Member one dot mother e mother two dot
mother sono array di caratteri e gli array di caratteri sono essenzialmente puntatori.
Quindi possiamo passarli allo str compare. Str confrontare tornerà uguale se sono la stessa cosa, quindi quello
che stiamo facendo qui è controllare che il membro una madre
e il membro due madre siano la stessa cosa. E se lo sono, torneremo veri.
Perché se entrambi hanno lo stesso nome
e quello sarebbe davvero il cognome, allora sono fratelli.
Abbastanza diretto.
Facile passare argomenti alle funzioni
fintanto che la dichiarazione della funzione contiene quel tipo di struttura.
Quindi questa funzione, ancora una volta, due parametri ciascuno dei quali è una struttura
di tipo famiglia.
E se volessimo avere puntatori a strutture come argomenti di funzione.
E ho detto prima, è meglio farlo perché stiamo
passando per valore e c.
Quando passi per valore, copi.
Se hai una struttura che contiene molti
dati, molte strutture grandi come argomenti,
devi copiare tutto in quella struttura
nella funzione effettiva.
Quindi potrebbe volerci del tempo
per copiare quelle grandi strutture.
Bene, se hai un puntatore, tutto ciò che devi fare è copiare
l'indirizzo che è molto più veloce. Quindi i puntatori alle
strutture vengono utilizzati come parametri e funzioni per evitare il consumo
di memoria e il tempo necessario per copiare tutte le strutture.
Ora, se hai una struttura piccola, niente
di grave, ma sicuramente vuoi usare puntatori e strutture grandi.
Quindi in questo caso cosa fate, specificate comunque il nome dei tipi di
struttura, vi basta mettere prima
l'asterisco, molto semplice. E se non vuoi
che nessuno dei dati all'interno della struttura cambi, puoi usare la costante prima del tipo di struttura.
Se non vuoi che l'indirizzo cambi, metti la costante dopo il puntatore della famiglia struct.
Ma qui stiamo facendo la stessa cosa. Ma ora ci accediamo in
modo diverso perché ora che è un puntatore possiamo usare il trattino
maggiore di, quel nuovo simbolo per accedere invece di usare il punto.
Non dobbiamo usare il punto qui. Perché ricorda,
i puntatori devi prima de-referenziare quindi dovresti metterlo tra parentesi, è più sintassi
de-referenziare il puntatore quindi dovresti mettere il punto fuori dalle parentesi perché ha precedenza
più alta, molto più facile da usare il trattino che maggiore di.
Trattino e maggiore di madre, trattino
e maggiore di madre sono entrambi indicatori, possono essere passati nel confronto str.
Se sono uguali, restituisci vero. Altrimenti, restituisci falso, piuttosto semplice.
Puoi anche usare il modificatore const come ho
detto se non vuoi consentire alcuna modifica dei membri della struttura.
A cosa punta la struttura, quindi metti la const prima del puntatore.
Potresti mettere la const in realtà anche prima della famiglia.
In questo caso, la famiglia ha un tipo f.
Quindi qui sarebbe davvero
costruisci la famiglia o il puntatore a const della famiglia della struttura.
E poi accedi di nuovo allo stesso modo, non stai modificando nulla. Quindi sei a posto.
Il compilatore non si lamenterà.
È inoltre possibile utilizzare il modificatore costante se non si desidera
consentire alcuna modifica dell'indirizzo stesso.
Qualsiasi tentativo di modificare queste strutture causerà un messaggio di errore durante la compilazione.
Quindi qui diresti star
della famiglia e metti la costante dopo la stella.
E ciò che questo sta dicendo è che non
puoi cambiare il valore di p-membro, il valore del puntatore, che è un indirizzo.
Ma ancora una volta, questo non è molto
utile perché quando passi per valore, stai effettivamente trasmettendo una copia dell'indirizzo.
Quindi questo è ridondante, non è necessario farlo, ma puoi farlo.
E qui, ancora una volta, vuoi essere in grado di cambiare l'indirizzo di ciò che è membro p.
E in questo caso, stai comunque accedendo ai dati per vedere se sono uguali.
L'operatore di riferimento indiretto in ogni definizione di parametro si trova
ora davanti alla parola chiave costante.
Quell'asterisco, non è davanti al nome del parametro.
Non è possibile modificare l'indirizzo memorizzato nei puntatori perché è dopo l'asterisco.
Se era davanti al tipo di nome del parametro, allora
vuoi essere in grado di modificare l'effettivo ciò a cui punta.
Se avessimo quell'operatore di riferimento indiretto davanti al nome del parametro, cosa sarebbe nella costante
prima di esso, ciò significherebbe che vuoi
essere in grado di modificare ciò a cui punta. Questo sta solo dicendo l'indirizzo.
Quindi non è possibile modificare l'indirizzo memorizzato nei puntatori.
Sono i puntatori che sono protetti qui, non le strutture
a cui puntano, proprio come i parametri dei puntatori costanti e altri, nessuna differenza con le strutture.
Se vuoi restituire una struttura da una funzione che è un
puntatore, il prototipo della funzione deve indicare questo valore di ritorno nel
modo normale nella dichiarazione.
Quindi qui dovresti dire colpito per uscire
con il mio puntatore
divertente o meno, non importa. Questo è un prototipo per una funzione senza argomenti che restituisce
una struttura di tipo data, molto facile restituire una struttura da una funzione. E qual è il valore di questo.
Bene, ora possiamo restituire più di
un elemento o un elemento di dati da una funzione.
Se stai restituendo una struttura, potresti restituire 10 valori, 10 diversi elementi di dati.
Quant'è fico. La struttura ti consente di restituirne più di una da una funzione.
Molto, molto prezioso.
Quindi è spesso più conveniente restituire un puntatore a una struttura anziché solo alla struttura.
Quando si restituisce un puntatore alla struttura, viene creato sull'heap perché
tutti i puntatori vengono creati sull'heap.
Ciò significa che durerà un po 'più a lungo.
E questo significa che puoi eliminarlo e gestirlo in momenti arbitrari.
Quindi, in questo esempio, stiamo creando una struttura chiamata funds.
Contiene un array di
caratteri denominato bank, contiene un double, un altro carattere
denominato salvato di una lunghezza particolare. La lunghezza del divertimento presunta è pari a 50.
E poi ne ha una doppia salvata.
Abbiamo una funzione chiamata somma che prende quella struttura come parametro.
E tutto ciò che stiamo facendo è restituire un
- il fondo bancario dalla prima struttura più il fondo di risparmio,
e questo restituirà l'importo che hanno nella loro banca.
In questo esempio, la somma è solo un doppio.
Non stiamo restituendo un puntatore. Stiamo solo prendendo un puntatore come parametro.
E così nella nostra funzione principale, stiamo creando una variabile di
struttura chiamata stan di tipo struct funds.
Lo stiamo inizializzando con alcuni valori e quindi stampiamo il totale
della somma delle chiamate. E passiamo semplicemente questa struttura come passiamo qualsiasi variabile.
Non dobbiamo de-referenziarlo, non è un puntatore. Non dobbiamo fare davvero niente di speciale.
Ci assicuriamo solo che nella dichiarazione della funzione ci sia quel tipo di struttura, ma
tutto il resto sembra normale.
Un paio di promemoria.
Ho detto prima che dovresti sempre usare i puntatori quando passi le strutture a una funzione.
Perché? Perché ricorda, le versioni precedenti di
c non
consentono il passaggio di strutture, ma consentono i puntatori.
Quindi puoi evitare qualsiasi tipo di compatibilità con le versioni precedenti.
Se stai usando una versione precedente di c, il tuo programma funzionerà.
Quindi anche il solo passaggio di quell'indirizzo singolo
è più efficiente a causa del tempo di copia.
Ma se lo fai, se passi un parametro che è un puntatore
a una struttura all'interno di una funzione, ha meno protezione per i tuoi dati.
Quindi alcune operazioni nella funzione chiamata potrebbero inavvertitamente influenzare i dati
nella struttura originale.
Ed è qui che vuoi usare il qualificatore const.
E useresti la const prima del tipo
effettivo, non dopo l'asterisco e prima del nome
del parametro, prima del tipo.
Il vantaggio di passare le strutture sono gli argomenti, la
funzione lavora con le copie dei dati originali.
È più sicuro che lavorare con i dati originali.
Quindi questa è davvero l'unica volta in cui vuoi passare una struttura come argomento che non è un puntatore.
E lo stile di programmazione tende ad essere un po 'più chiaro.
I principali svantaggi del passaggio di strutture come argomenti rispetto al passaggio di
un puntatore strutturato come argomento sono le
implementazioni più vecchie potrebbero non gestire il codice, spreca
tempo e spazio ed è particolarmente
dispendioso quando si hanno strutture di grandi dimensioni che dobbiamo copiare
molto per ciascuna membro. Quindi tienilo a mente.
Per la maggior parte si desidera passare puntatori
a strutture, molto più efficienti e che fanno risparmiare tempo.
I programmatori usano puntatori di struttura come argomenti di funzione per ragioni di efficienza
e usano costanti quando necessario. E questa è la combinazione che vuoi fare.
Se sei preoccupato per la protezione, usa semplicemente il puntatore a
funzione per l'efficienza e poi usa const
const in modo che nulla si incasini all'interno della
funzione, proprio come i puntatori veramente normali più
o meno, ma con i puntatori è ancora più importante con l'efficienza
perché di grandi strutture.
Il passaggio di strutture in base al valore viene spesso eseguito per strutture piccole e
queste sono le regole a cui vuoi pensare.
Va bene passare una struttura che non è un puntatore fintanto che è piccola.
Di nuovo, alcuni importanti concetti relativi alle strutture
e al passaggio di puntatori come parametri, argomenti
e anche restituzione di puntatori. Ora, possiamo effettivamente iniziare a implementare
alcuni di questi. Forniamo molti esempi. Comprendiamo i concetti. Comprendiamo la sintassi.
Ora voglio presentarti un paio di sfide che ti fanno effettivamente fare questo, hai memorizzato
nella sintassi che ora se vuoi creare una struttura nel programma, sai come farlo
come il palmo della tua mano.
Quindi avremo un paio di sfide nelle prossime due
conferenze per farti conoscere tutte le cose di cui abbiamo parlato riguardo alle strutture.
Grazie.