Hallo, en welkom terug. Het laatste waar ik het over wil
hebben met betrekking tot structuren, is hoe ze gerelateerd zijn aan
functies, hoe je structuren als argument kunt doorgeven aan een parameter en een functie en
hoe dit ook efficiënter is.
Dus structuren als argumenten voor functies.
Na het declareren van een structuur
met de naam Family. In dit voorbeeld gaan we een benoemde
familie maken, hoe geven we deze structuur als argument door aan een functie.
Dus we hebben deze structuur genaamd Familie.
We hebben een heleboel karakterreeksen in haar
naam, vader en moeder en dan hebben we een int leeftijd.
Dat is onze structuurdefinitie.
We weten dat het een structuur is omdat het struct-sleutelwoord daar is, gevolgd door de
tagnaam die we hebben, onze accolades, enzovoort.
Hoe geven we die structuur nu eigenlijk door aan een functie
die broers en zussen wordt genoemd?
Nou, je zou het doen zoals je de structuur declareert,
je zou het type als de parameternaam zeggen.
Het is echt rechttoe rechtaan. Dus in dit geval hebben we Booleaanse broers en zussen.
Broers en zussen geeft een Boolean terug.
En er zijn twee parameters nodig, twee structparameters.
U moet het struct-type identificeren dat type struct-familie is.
Nu, in meer geavanceerde c, zou je eigenlijk een
typedf op deze struct kunnen doen en het iets anders kunnen noemen en je zou de naam
hier kunnen inkorten, maar we hebben het nog niet gehad over typeds.
Dat zou waarschijnlijk beter zijn.
Maar dit is echt hoe je het zou moeten doen. Je zou het hele type moeten definiëren,
dat is de struct-familie en dan de naam van de variabele, net als elke andere parameter.
Dus hier geven we twee parameters door, lid één en lid twee.
Ze zijn allebei van het type structfamilie.
Als we binnen onze functie toegang willen tot leden, hebben we toegang
tot leden, net als normaal.
Lid één en lid twee, het zijn geen wijzers, dus we gebruiken het streepje dan niet groter dan, we doen
dat alleen voor de wijzers omdat we ze moeten de-refereren om te zien waar ze naar verwijzen.
Omdat het geen wijzers zijn, kunnen we gewoon punt maken. Dus lid één punt moeder, lid twee punt moeder.
Member one dot mother en mother
two dot mother zijn karakterarrays, en karakterarrays zijn in wezen pointers.
Dus we kunnen ze doorgeven aan de str-vergelijking. Str vergelijk zal gelijken retourneren als ze hetzelfde zijn, dus
wat we hier doen, is dat we controleren of lid
één moeder en lid twee moeder hetzelfde zijn. En als dat zo is, gaan we terug naar waar.
Want als ze allebei dezelfde naam hebben en dat
zou echt de achternaam zijn, dan zijn ze broers en zussen.
Vrij eenvoudig.
Makkelijk om argumenten door te
geven aan functies zolang de functiedeclaratie dat type struct bevat.
Dus deze functie, nogmaals, twee parameters die elk een structuur van een
typefamilie zijn.
Hoe zit het als we verwijzingen naar structuren als functieargumenten willen hebben.
En ik zei eerder dat dit beter is om te doen
omdat we waarde doorgeven en c.
Als je waarde doorgeeft, kopieer je.
Als je een structuur hebt die veel data
bevat, veel grote structuren als argumenten, dan
moet je alles in die structuur naar
de eigenlijke functie kopiëren.
Dus dat kan even duren om
die grote structuren te kopiëren.
Nou, als je een pointer hebt, hoef je alleen maar het adres
te kopiëren, wat veel sneller is. Dus verwijzingen naar structuren
worden gebruikt als parameters en functies om geheugengebruik en de tijd
die nodig is om alle structuren te kopiëren te vermijden.
Als je nu een kleine structuur hebt, geen
probleem, maar je wilt zeker pointers en structuren gebruiken die groot zijn.
Dus in dit geval, wat doe je, je geeft nog steeds de naam van de soorten
structuur op, je zet gewoon de
asterisk vooraf, heel eenvoudig. En als u niet
wilt dat een van de gegevens in de structuur verandert, kunt u constant vóór het structuurtype gebruiken.
Als u niet wilt dat het adres verandert, plaatst u de constante achter de struct-familieaanwijzer.
Maar hier doen we hetzelfde. Maar nu gaan we er anders
toegang toe krijgen, want nu het een aanwijzer is, kunnen we het streepje groter dan
gebruiken, dat nieuwe symbool om toegang te krijgen in plaats van de punt te gebruiken.
We hoeven de punt hier niet te gebruiken. Want onthoud, pointers
moet je eerst de-refereren, dus je zou het tussen haakjes moeten zetten, het is meer
syntaxis om de pointer te de-refereren dan zou je de punt buiten de haakjes moeten plaatsen omdat
het een hogere prioriteit heeft, veel gemakkelijker om het streepje te gebruiken dan groter dan.
Dash en groter dan moeder, streepje
en groter dan moeder, het zijn beide aanwijzingen, ze kunnen worden doorgegeven in de str-vergelijking.
Als ze hetzelfde zijn, retourneer dan waar. Geef anders false terug, vrij eenvoudig.
Je kunt ook de const-modifier gebruiken zoals ik al zei
als je geen wijziging van de leden van de struc wilt toestaan.
Waar de struc naar verwijst, plaats je de const voor de aanwijzer.
Je zou de const ook voor familie kunnen stellen.
In dit geval heeft familie een typef.
Dus hier zou
het echt een constructie-familie zijn of een struct-familie const-wijzer.
En dan weer toegang op dezelfde manier, je wijzigt niets. Dus je bent klaar om te gaan.
Compiler zal niet klagen.
U kunt ook de constante modifier gebruiken als u geen wijziging van
het adres zelf wilt toestaan.
Elke poging om deze structuren te wijzigen zal een foutmelding veroorzaken tijdens het compileren.
Dus hier zou je familiester
zeggen en je zet de constante achter de ster.
En wat dit zegt is dat je de waarde
van p-member niet kunt veranderen, de waarde van de pointer, wat een adres is.
Maar nogmaals, dit is niet erg handig, want als
je waarde doorgeeft, geef je in feite een kopie van het adres door.
Dit is dus overbodig, u hoeft dit niet te doen, maar het kan wel.
En hier, nogmaals, wil je het adres kunnen veranderen van wat p lid is.
En in dit geval heb je toch gewoon toegang tot de gegevens om te zien of ze gelijk zijn.
De indirecte-operator in elke parameterdefinitie staat nu
voor het constante sleutelwoord.
Dat sterretje staat niet voor de parameternaam.
U kunt het adres dat in de aanwijzers is opgeslagen niet wijzigen omdat het achter de asterisk staat.
Als het voor het type parameternaam stond, dan wil
je in staat zijn om te wijzigen waar het naar verwijst.
Als we die indirecte-operator voor de parameternaam hadden, wat dat zou zijn in
de constante ervoor, zou dat betekenen
dat je wilt kunnen wijzigen waarnaar het verwijst. Dit zegt alleen het adres.
U kunt het adres dat in de pointers is opgeslagen dus niet wijzigen.
Het zijn de pointers die hier worden beschermd, niet
de structuren waarnaar ze verwijzen, net als constante en andere pointerparameters, geen verschil met structs.
Als je een structuur wilt retourneren van een functie die
een pointer is, moet het functie-prototype deze retourwaarde op de normale manier
aangeven in de declaratie.
Dus hier zou je moeten zeggen dat ik tot op
heden mijn leuke wijzer ben
of geen wijzer, het maakt niet uit. Dit is een prototype voor een functie zonder argumenten die een structuur van
het type date retourneert, heel gemakkelijk om een structuur van een functie te retourneren. En wat is de waarde hiervan.
Welnu, nu kunnen we meer
dan één element of één gegevensitem van een functie retourneren.
Als u een struct retourneert, kunt u 10 waarden, 10 verschillende gegevensitems retourneren.
Hoe cool is dat. Met de struct kunt u meer dan één van een functie retourneren.
Zeer, zeer waardevol.
Het is dus vaak handiger om een aanwijzer naar een structuur terug te sturen in plaats van alleen de structuur.
Wanneer u een aanwijzer naar de structuur terugstuurt, wordt deze op de heap gemaakt omdat
alle aanwijzers op de heap worden gemaakt.
Dit betekent dat het nog wat langer gaat duren.
En dit betekent dat u het op willekeurige tijdstippen kunt verwijderen en beheren.
Dus in dit voorbeeld maken we een structuur met de naam fondsen.
Het bevat een tekenreeks met
de naam bank, bevat een dubbel, een ander teken met
de naam opgeslagen van een bepaalde lengte. Gewoon aangenomen dat de plezierlengte gelijk is aan 50.
En dan heeft het een dubbel opgeslagen.
We hebben een functie genaamd som die die structuur als parameter neemt.
En alles wat we doen is van binnen, we geven
het bankfonds van de eerste structuur plus het spaarfonds terug, en dat zal
het bedrag teruggeven dat ze op hun bank hebben.
In dit voorbeeld is de som gewoon een dubbele.
We geven geen pointer terug. We nemen gewoon een pointer als parameter.
En dus creëren we in onze hoofdfunctie een structuurvariabele
genaamd stan van het type structfondsen.
We initialiseren het met enkele waarden, en dan printen we het totaal
van de aanroepende som. En we geven deze structuur gewoon door zoals we elke variabele doorgeven.
We hoeven het niet te de-refereren, het is geen aanwijzer. We hoeven niet echt iets speciaals te doen.
We zorgen er gewoon voor dat we in de functiedeclaratie dat struct-type daar hebben, maar al
het andere ziet er normaal uit.
Een paar herinneringen.
Ik heb eerder gezegd dat je altijd pointers moet gebruiken bij het doorgeven van structuren aan een functie.
Waarom? Want onthoud, oudere versies van c
staan niet toe
dat structuren worden doorgegeven, maar ze laten wel verwijzingen toe.
U kunt dus elke vorm van achterwaartse compatibiliteit vermijden.
Als je een oudere versie van c gebruikt, zal je programma werken.
Dus alleen dat ene adres
doorgeven is ook efficiënter vanwege tijd kopiëren.
Maar als u dit doet, als u een parameter doorgeeft die een verwijzing
is naar een struct in een functie, heeft deze minder bescherming voor uw gegevens.
Sommige bewerkingen in de aangeroepen functie kunnen dus onbedoeld de gegevens in
de oorspronkelijke structuur beïnvloeden.
En dit is waar je de const-kwalificatie wilt gebruiken.
En u zou de const vóór het
eigenlijke type gebruiken, niet na de asterisk en vóór
de parameternaam, vóór het type.
Het voordeel van het doorgeven van structuren zijn argumenten, de
functie werkt met kopieën van de originele gegevens.
Het is veiliger dan werken met de originele gegevens.
Dus dat is echt de enige keer dat je een structuur wilt doorgeven als een argument dat geen pointer is.
En de programmeerstijl is meestal een beetje duidelijker.
De belangrijkste nadelen van het doorgeven van structuren als argumenten in tegenstelling tot het
doorgeven van een gestructureerde aanwijzer als argument,
is dat oudere implementaties de code mogelijk niet aankunnen,
het verspilt tijd en ruimte en
het is vooral verspilling als je grote structuren hebt, we moeten veel
kopiëren voor elk lid. Houd hier dus rekening mee.
Voor het grootste deel wil je
verwijzingen naar structuren doorgeven, veel efficiënter en tijdbesparend.
Programmeurs gebruiken structuuraanwijzers als functieargumenten om redenen van efficiëntie en ze gebruiken
constant wanneer dat nodig is. En dit is de combinatie die je wilt doen.
Als je je zorgen maakt over de bescherming, gebruik dan gewoon
de functieaanwijzer voor efficiëntie en gebruik dan
de const const zodat er niets in de functie
wordt verpest, net als echt normale aanwijzers min
of meer, maar met aanwijzers is het nog belangrijker met de efficiëntie
omdat van grote constructies.
Het doorgeven van structuren op waarde wordt meestal gedaan voor structuren die klein zijn, en dat zijn
een soort regels waar u aan wilt denken.
Oké om een structuur door te geven die geen pointer is, zolang hij maar klein is.
Nogmaals, enkele belangrijke concepten hebben betrekking op structuren
en het doorgeven van pointers als parameters,
argumenten en ook terugkerende pointers. Nu kunnen we een deel hiervan
daadwerkelijk gaan implementeren. We geven veel voorbeelden. We begrijpen de concepten. We begrijpen de syntaxis.
Nu wil ik je een paar uitdagingen voorleggen waardoor je dit echt doet, je hebt onthouden in
de syntaxis dat als je nu ooit een structuur in het programma wilt creëren, je weet hoe
je het moet doen met je broekzak.
Dus we zullen een paar uitdagingen hebben in onze volgende paar lezingen om
je bekend te maken met al deze dingen waar we het over hebben gehad met betrekking tot structuren.
Dank u.