Hallo, en welkom terug.
Ik wil graag een oplossing bieden voor: vorige uitdaging in deze lezing.
Een demonstratie van hoe je kan pointers hebben als elementen in de
structuur en ook: pass rond wijzers twee functies
die structuren zijn.
Dus laten we code ter sprake brengen blokken, maak een nieuw project.
Dit wordt een console toepassing, en we gaan dit voorbeeld
van structuuraanwijzers een naam geven.
En dus als je je herinnert voor de
vereisten hiervoor, dit was eigenlijk gewoon een producttype structuur waarin een itemnaam, een hoeveelheid, een prijs
en een bedrag zijn opgeslagen.
En de naam van het item ging karakteraanwijzer zijn.
Je zou een bedrag dat in feite de hoeveelheid
in prijs vermenigvuldigde.
En toen hadden we twee functies dat zal als parameters
verwijzen naar een struct.
Dus het eerste wat we zijn gaan doen, is
dat we onze structuur gaan creëren.
En ik noemde dit eerder, maar het is goed om
de structuur globaal te maken, want als je wilt: gebruik het in meerdere functies.
De structuur maken definieert het echt.
Je wijst geen geheugen toe.
Dus het kan geen kwaad globaal stellen.
En ze gaan meestal naar binnen het header-bestand toch.
Dus om een structuur te creëren, we zeggen gewoon structuur.
We gaan dit item noemen, en we gaan vier elementen hebben.
We krijgen een personage pointer, die we gewoon
itemnaam gaan noemen.
We gaan een hoeveelheid hebben.
We gaan floaten voor de prijs, en we gaan een
float houden voor het bedrag.
En zo kunnen we definiëren onze structuur, vrij eenvoudig.
Nu binnen onze hoofdfunctie, we wil een variabele maken voor het structuurtype en ook
een aanwijzer.
Dus het eerste wat we willen doen is willen we gewoon zeggen struct item met de
naam van de structuur en dan noemen we dit item gewoon.
En dit is gewoon het creëren van een vreemde aanwijzer.
Dit gaat geheugen toewijzen voor de vier variabelen en elementen
binnen de structuur.
En dus willen we onze aanwijzer maken nu, en we kunnen gewoon zeggen struct item.
We gaan zeggen p item omdat we onze pointers
meestal het voorvoegsel p noemen.
Dus we zeggen het sterretje, en we zeggen p item.
En dan in de volgende
regel, we willen gewoon toewijzen aan ons pointer-item, ons item.
Dus we moeten de gebruiken adres van en we zeggen item.
En hier hebben we het geheugen toegewezen voor elementen in onze structuur voor
onze aanwijzer.
We hebben geen geheugen toegewezen voor onze karakteraanwijzer
die onze itemnaam is, dus dat zou de volgende stap zijn.
Nu vraag je je misschien af waarom we nodig hebben? om de itemstructuur te maken.
Wij niet echt.
We kunnen gewoon de aanwijzer maken, en de aanwijzer gaat alleen geheugen
creëren voor die struct-itemaanwijzer.
Het zal geheugen toewijzen voor de int
en floats, maar we moeten nog steeds de itemnaamtoewijzing doen.
Ik doe dit gewoon graag omdat dit is meestal de goede gewoonte.
Typisch wat je zou doen met de eerste itemstructuur is dat je het
zou initialiseren, en dus jij enige initialisatie zou hebben.
Maar dat hoeven we niet te doen.
Dus het eerste wat we willen doen is geheugen toewijzen voor onze itemnaam.
Dus we kunnen in principe a . gebruiken speciale operator om toegang te krijgen tot elementen als
het een aanwijzer is.
Denk eraan, voor structuren die: zijn aanwijzers, je hebt het streepje dan groter dan het symbool
dat je kan gebruiken om toegang te krijgen tot de elementen.
Anders zou je de-referentie moeten de-refereren de aanwijzer om toegang te krijgen tot de elementen.
We zouden iets kunnen doen als dit tussen haakjes.
We kunnen de verwijzing naar de aanwijzer verwijderen,
dus we zouden zoiets als star p item moeten doen en dan moeten gebruiken de punt om toegang te krijgen tot elementen.
Dit is volkomen geldig om zoiets te doen.
Maar het is een soort extra syntaxis die je niet echt nodig hebt.
Dus c heeft een speciale syntaxis die: u kunt gebruiken wanneer uw structuur een aanwijzer
is als u toegang wilt tot de elementen.
Je kunt eigenlijk gewoon de naam zeggen van de aanwijzer die p item is en gebruik dan
het streepje dan groter dan.
En in dit geval willen we: geheugen toewijzen voor itemnaam.
Dus we gaan het toewijzen wat is terug van de malloc-functie.
Onthoud, de malloc-functie geeft een lege aanwijzer terug.
Dus we moeten het casten tot een karakterster.
Maar we kunnen gewoon malloc bellen, gewoon zeg malloc en dan de grootte van de
bytes die we willen maken.
In dit geval zeggen we gewoon 30, en we vermenigvuldigen het met de grootte van char,
voor het geval char a . is verschillende grootte op verschillende computers.
En dit gaat toewijzen geheugen voor onze itemnaam.
We moeten dit doen omdat de naam van het item: is een aanwijzer binnen de structuur.
Het heeft geen geheugen toegewezen wanneer u het
aan een andere structuur toewijst.
Dit moeten we dus doen.
Nu het eerste wat je wilt wat u moet
doen nadat u het geheugen hebt toegewezen, is het controleren van de malloc.
dus we willen hier controleren op null.
We gaan gewoon zeggen als p item, if het is nul dat zou zeggen dat het nul is.
Anders zou je zeggen, zo niet, dan zou je dat wel kunnen zeg gewoon terug of afsluiten zou waarschijnlijk beter zijn, verlaat het programma
als we waren niet in staat om geheugen toe te wijzen en je kon
het doorgeven aan negatief.
Anders willen we lezen in een item, dus we willen een functie maken.
De functie waar we naartoe gaan te maken heet gelezen item.
Laten we een functiedeclaratie plaatsen hier boven de structuur.
Het gaat gewoon gegevens inlezen in de structuur die we eraan hebben doorgegeven.
Het gaat geen gegevens retourneren.
Dus we kunnen gewoon zeggen lees item en er is een struct voor nodig, en dat wordt een
aanwijzer.
Het is dus een structureel item, asterisk I.
Nu kunnen we dit een constante maken dus de waarden veranderen een
beetje, maar we veranderen de waarden.
Maar we zouden kunnen zeggen constante structuur, de waarden zouden niet kunnen veranderen
voor die aanwijzer waarnaar deze verwijst.
Als we de constante erna deden het sterretje, dat zou zeggen dat het adres niet kan
veranderen of rechts voor het sterretje zoiets achter
de naam.
Dat zou zeggen dat het adres dat niet kan
wijzigen, maar dat is overbodig omdat we de kopieerwaarde doorgeven.
We hebben ons gelezen item.
En terwijl ik hier ben, zou ik misschien doe ook mijn afdrukitem.
Dat wordt gewoon de functie verklaring, functie prototype.
Hier, het wordt erg vergelijkbaar, neem ook een wijzer.
Kan een ruimte hebben als je wilt na het sterretje of niet?
Nu kunnen we onze read . definiëren item onder onze belangrijkste methode.
En dit gaat lezen in waarden van item en bereken
vervolgens het totale bedrag.
Dus we kunnen zeggen void read item, hebben onze pointer.
En hier binnen, we willen gewoon om echt wat scanfs te gebruiken.
We gaan wat berichten uitprinten om de gebruiker te vertellen om informatie in te voeren.
Dus we gaan zeggen enter productnaam, en dan gaan we het
inlezen.
Dus we gaan scanf zeggen, en we hebben een verwijzing naar een struct, zodat we er toegang toe
hebben met behulp van het streepje dan groter dan.
We willen inlezen voor scanf, de productnaam is een karakterbuffer.
Dus we willen procent s zeggen en dan gaan we zeggen ik, we gaan het
opslaan in de itemnaam.
En we zouden terug kunnen gaan en de intellisense ga gewoon naar de itemnaam.
We hoeven de niet te gebruiken adres van de operator omdat
het een karakteraanwijzer is.
We willen dan afdrukken en krijgen de prijs,
wilt u hier waarschijnlijk wat regelfeeds toevoegen, voer dan de prijs in.
We gaan opslaan dat in de structuur.
Dus nogmaals, de prijs is een float.
Dus ik ga procent f zeggen, maar we gaan het ook openen omdat het een aanwijzer is, we willen het
nog steeds gebruik het streepje dan groter dan.
Behalve deze keer gaan we zeg prijs, en we moeten het adres ervan krijgen, dus we gaan naar
zet er een ampersand voor omdat de prijs
geen wijzer is.
En dan gaan we de hetzelfde voor de hoeveelheid.
Dus hoeveelheid is een geheel getal.
Dus we kunnen procent d zeggen, we hebben nog steeds nodig om het adres ervan
te krijgen, maar we willen het in een ander element opslaan, we willen het opslaan in de hoeveelheid.
Nu we het hebben opgeslagen of gevraagd de gebruiker om drie
informatie-items in te voeren, nu kunnen we: daadwerkelijk het bedrag berekenen, iets in
het bedrag opgeslagen.
Het bedrag is gewoon de hoeveelheid maal de prijs.
Dus we willen nog steeds toegang tot de structuur met onze syntaxis, we
willen het casten, we willen ondertekenen de hoeveelheid maal de prijs.
En dat is de functie voor het lezen van items.
Neemt een structuurwijzer.
En dus wanneer we deze aanwijzer wijzigen binnen het gelezen item, wordt
het buiten de functie gewijzigd.
Dus welke structuur we ook deze functie overgaat, wordt
deze gewijzigd.
Het gaat alle opslaan artikelen, de artikelnaam, prijs en
hoeveelheid en bedrag.
Dus dat leest in de gegevens.
Op dit punt zou je willen test en u wilt
waarschijnlijk eerder compileren en testen.
Maar we kunnen nu het gelezen item noemen methode in onze main en geef het door
in onze structuur die we hebben gemaakt.
Dus we kunnen zeggen lees item, en we kunnen gewoon zeggen p item.
We hoeven niet in de adres omdat het een aanwijzer is, dus
we gaan gewoon door in onze structuur.
En dan het volgende dat we wat u kunt doen, is dat we het kunnen afdrukken.
En wat dit je zal laten zien is dat de gegevens zijn opgeslagen,
p item wordt gewijzigd in de functie en het wordt opgeslagen buiten de functie,
de hoofdfunctie heeft deze waarden daadwerkelijk opgeslagen.
Dus we kunnen zeggen print item passeren opnieuw in de aanwijzer, en dan kunnen we de functie
afdrukitem definiëren.
Afdrukitem is vrij eenvoudig.
Het levert niets op, dus we zeggen void en we zeggen
dat print item een pointer nodig heeft.
Dus we zeggen gewoon struct item star Ik, hoe je het ook wilt noemen.
En dan printen we de gegevens gewoon uit voor de structuur die werd doorgegeven.
Dus we zouden iets doen als printf naam procent s, I item naam, I prijs,
I hoeveelheid en I bedrag en dan formatteren we de gegevens.
Wat is het laatste dat we hebben?
om in het algemeen te doen nadat we de gegevens hebben afgedrukt, de echt belangrijke gratis functie.
We moeten gratis bellen omdat we wil het geheugen vrijmaken dat we hebben
toegewezen aan de itemnaam.
Dus we kunnen gewoon zeggen gratis p item en open vervolgens de itemnaam.
We willen niet de hele structuur omdat
de hele structuur zal worden verwijderd op de stack wanneer de functie terugkeert.
We willen gewoon vrijmaken wat we hebben mishandeld.
We hebben alleen gehamerd voor item naam, zodat we die vrijmaken, en dan komen
we terug van de main.
Dus laten we doorgaan en probeer dit te bouwen.
En we hebben een fout.
Laten we eens kijken of er struct item star staat.
Dus we hadden een fout waar de functies werden boven de
structuur gedefinieerd.
Maar de functie van het nemen van een parameter als een structuurtype.
Dus we moeten de structuur hebben hierboven gedefinieerd waar we het gebruiken.
Dus ik verplaats de functies tot lijn 12 en 13.
Nu kunnen we compileren.
Laten we doorgaan en dit uitvoeren.
En laten we eens kijken wat we hier krijgen.
We hebben nog een fout.
Je moet ervoor zorgen dat je controleer p item voor null.
Als je gewoon zegt als p item voor waar, het zal altijd waar zijn.
U kunt dus ofwel controleren om te zeggen het is niet waar met het
niet-symbool, wat betekent dat het niet null of jij is kan controleren of het null is.
Dus ik heb de null daar gewoon toegevoegd.
Dus nu voeren we het uit, we moet goed zijn om te gaan.
We kunnen de productnaam invoeren.
We zeggen serieel, en we zullen zeg dat de prijs 1 is. 99.
En we zullen zeggen dat we er vijf hebben.
En nu printen we het uit, en we zeggen seriële dollar 99.
5, het totale bedrag is 9. 95.
De prijs vind ik niet leuk hoe de prijs wordt afgedrukt.
Dus laten we dat oplossen.
In ons printitem kunnen we gewoon zeggen voor prijs dor 2 f drijft, nu zien we
er een beetje beter uit, en we voeren het uit.
We krijgen een beetje beetje beter formaat.
Vier van hen en nu is het ziet er een beetje beter uit, en
alles is goed om te gaan.
Dus nogmaals, basisprogramma met behulp van structuren en aanwijzingen.
We hebben de structuur bovenaan gemaakt.
We hebben een lid dat: een pointer, het is erg efficiënt
om dat te doen omdat we het kunnen kopieer en adressen gewoon
in tegenstelling tot tekenarrays.
We hebben onze twee func-verklaringen, lees item print item
dat pointers vernietigt.
En dan maken we de aanwijzer en wijs het toe aan een reguliere
structuur in onze main.
We wijzen geheugen toe op regel 22.
Wij zorgen ervoor dat het geheugen is succesvol toegewezen als dat niet het geval
was, verlaten we het programma.
En dan noemen we onze twee functies die
verwijzingen naar structuren geven, doorgeven.
En dan last but not least, we maken het geheugen vrij en dan verlaten
we het programma.
En de functies zijn: vrij eenvoudig.
Je neemt die wijzer.
U opent de aanwijzer met het streepje dan groter dan.
En je krijgt het adres van het voor scanfs die geen
pointers als elementen hebben.
En dat is het eigenlijk.
Ik sla dit programma op, je kijkt er eens naar.
Laat het me weten als je vragen hebt. Dank u.