Hallo en welkom. We zitten in een nieuwe rubriek.
We gaan het hebben over structuren.
Dit is een nieuw concept in c waarmee
je items kunt groeperen, vergelijkbaar met array maar krachtiger.
Ik wil het hebben over wat een structuur is, hoe je een structuur kunt maken en
hoe je een structuur kunt gebruiken.
Dus structuren in c bieden een ander hulpmiddel om elementen samen te groeperen.
Nogmaals, ik zei dat ze vergelijkbaar zijn met een array, maar dat ze eigenlijk een beetje krachtiger zijn.
Als je bekend bent met
objectgeoriënteerd programmeren, als je programmeert in java
of c-plus plus of een andere objectgeoriënteerde taal, dan wordt
het gezien als een object, maar alleen met gegevensleden, geen feitelijk gedrag, geen methoden.
Het is dus een
krachtig concept dat je in veel c-programma's die
je ontwikkelt zult gebruiken, omdat je verschillende items in
één naam kunt groeperen en die in wezen data-attributen kunnen vertegenwoordigen.
Stel bijvoorbeeld dat u een datum in een programma wilt opslaan.
Een datum bestaat meestal uit drie variabelen: maand, dag en jaar.
U zou die drie variabelen maken om die gegevens op te slaan.
U zou bijvoorbeeld zeggen dat int maand gelijk is aan 9 dag is gelijk aan 25
jaar is gelijk aan 2015.
Stel dat uw programma ook de aankoopdatum van een bepaald artikel moet opslaan.
Nou, je zou waarschijnlijk drie extra variabelen moeten maken voor elke
datum die je in je programma gebruikt. Dus je kunt zien hoe dit
erg repetitief kan worden en je uiteindelijk veel variabelen creëert.
Maar wat u moet opmerken, is dat deze variabelen logisch gerelateerd zijn. Het zijn allemaal dates.
Ze zouden eigenlijk bij elkaar moeten worden gegroepeerd.
Ze zouden bijna hun eigen gegevenstype moeten zijn en dan zou je ze moeten kunnen maken en
toegang krijgen tot de verschillende elementen.
U hoeft niet voor elke afzonderlijke datum drie afzonderlijke variabelen te maken.
Dus nogmaals, hier komt het in relatie tot objecten
en een klasse die drie gegevensattributen heeft.
Het zou dus veel beter zijn als je deze sets van drie variabelen op de een of andere manier zou kunnen groeperen.
En dit is precies wat het structuurelement doet en c.
Hiermee kunt u deze verschillende elementen groeperen met een bepaalde naam.
Je kunt dan verschillende variabelen met die naam maken
en toegang krijgen tot de elementen
in die naam, de verschillende gegevensattributen, ze worden in feite leden genoemd.
Dus hoe maak je een structuur in c.
Het is heel erg eenvoudig. Structuurverklaring beschrijft hoe een structuur wordt samengesteld.
Welke elementen zich in de structuur bevinden.
En we noemen deze elementen meestal leden.
Omdat je eerst de structuur moet definiëren of de structuur moet declareren,
beschrijf dan wat er in de structuur zit.
En dat doe je dus met het sleutelwoord struct.
Met het sleutelwoord struct kunt u een verzameling variabelen
van verschillende typen definiëren, een structuur genaamd, die u als een enkele eenheid kunt behandelen.
Heel, heel krachtig.
Dus door dit struct-sleutelwoord te gebruiken, hoeft u alleen maar een naam op
te geven, en dit wordt meestal de tagnaam genoemd. In dit voorbeeld hebben we een tagnaam van datum.
Maar je ziet het sleutelwoord struct, dat is het sleutelwoord dat de
c-compiler vertelt dat dit een specifieke functie gaat worden.
Dit kan specifieke functionaliteit hebben waarmee u elementen kunt groeperen.
Dus struct is het sleutelwoord gevolgd door de tagnaam
en dan heb je de linker accolade en
de rechter accolade gevolgd door een puntkomma om te eindigen.
En dan daarbinnen kun je alle soorten variabelen definiëren die je wilt, je kunt er zelfs wijzers in plaatsen.
En die worden de leden van de structuur genoemd.
Dus dit is opnieuw een statement, het definieert een
datumstructuur die de c-compiler zal begrijpen.
Het vertelt de c-compiler wat de staatsstructuur gaat
bevatten, drie elementen: maand,
dag en jaar. Er is geen geheugentoewijzing voor deze aangifte.
Nogmaals, wat je zegt is dat dit een structuur is die bestaat.
Ik ben het nog niet gaan gebruiken. Ik zei net dat dit is hoe het zal worden gedefinieerd.
Dit wordt de datumstructuur en dit is waar het uit bestaat.
De variabelen namen binnen de datumstructuur, de maand de dag en het
jaar, die worden leden of velden genoemd.
Leden van de structuur verschijnen tussen de accolades
die volgen op de naamdatum van de structtag, dus de datum van de tagnaam.
Zeer, zeer eenvoudige syntaxis om deze elementen samen te groeperen in een enkele naam die datum is.
En je merkt dat het anders is dan een array omdat
er geen indices zijn, je specificeert niet echt een grootte.
Het is niet exact hetzelfde gegevenstype.
U kunt verschillende gegevenstypen hebben en u kunt veel verschillende hebben.
Dus hoe zou u deze structuur gebruiken.
Welnu, de definitie van datum definieert een nieuw type in de taal.
Je kunt het echt zien als een ander type, net als een int, een double of float.
Behalve dit type dat je hebt gedefinieerd, kun je het bijna zien als een opsomming.
Behalve dat een opsomming maar één waarde heeft.
Deze datumstructuur kan drie waarden bevatten, maar het is een ander gegevenstype.
Variabelen kunnen nu van het type struct-to-date worden verklaard.
Dus dat is precies wat je zou doen.
Je zou een nieuwe variabele kunnen maken met de naam vandaag en
het wordt het type struct date van het type.
En vandaag zal in wezen in staat zijn om drie waarden vast te houden.
En als u dan meer datums moet
declareren, kunt u meer variabelen van hetzelfde type maken.
En zo hoef je niet langer drie aparte variabelen voor een aankoopdatum, drie
aparte variabelen voor de huidige datum,
drie aparte variabelen voor een factuurdatum te hebben.
U kunt één variabele
of twee variabelen van verschillende instanties van die feitelijke structuur hebben.
Nogmaals, hopelijk merk je hoe krachtig dit kan zijn.
Dus deze bovenstaande verklaring is van het type struct
date, aankoopdatum.
Geheugen is nu toegewezen omdat u hebt aangegeven dat de variabele
Geheugen is toegewezen voor deze structuur.
Geheugen wordt toegewezen voor de drie gehele waarden of de
drie leden van elke
variabele, zodat geheugen wordt toegewezen.
En ook de reden dat het wordt toegewezen is omdat er geen aanwijzingen in staan.
Als er pointers in die struct waren, zou u geheugen voor die pointer moeten toewijzen.
Maar aangezien deze datumstructuur van vandaag is, is het heel eenvoudig.
Ik begin langzaam, het bevat drie ints, die leden worden automatisch voor je toegewezen.
Maar zorg ervoor dat u dit onderscheid begrijpt van de vorige dia en deze huidige dia.
Er is een verschil tussen het definiëren van een structuur en het declareren van
de variabelen van dat specifieke structuurtype.
De financiële structuur vertelt de c-compiler gewoon dat dit een structuur
is en dit - dit zijn de gegevens die erin zitten.
Maar het declareren van een variabele van dat specifieke structuurtype
betekent dat ik die structuur ga gebruiken.
Ik heb nu geheugen toegewezen voor de drie elementen in ons voorbeeld, en ik
kan toegang krijgen tot die elementen en ze instellen.
Dus hoe krijg je toegang tot de leden in een struct?
Dus nu je weet hoe je een structuur
definieert en hoe je structuurvariabelen declareert, moet
je nu kunnen begrijpen hoe je naar die leden van struct moet verwijzen.
Je moet ze benaderen. Als u er geen toegang toe zou hebben om de waarden te zien of waarden in te stellen, zou het nutteloos zijn.
De naam van een structuurvariabele is dus geen pointer.
Je hebt dus een speciale syntaxis nodig om toegang te krijgen tot leden.
Omdat pointers meestal alleen de waarde van een adres
bevatten.
En als het geen aanwijzer is, heb je een speciale syntaxis nodig.
U kunt naar een lid van een structuur verwijzen door de naam van de variabele te schrijven gevolgd door een punt.
Het wordt meestal de puntoperator genoemd.
En dan na die puntoperatorperiode,
volg je de naam van de lidvariabele binnen die struct.
De periode tussen de naam van
de structuurvariabele en de naam van het lid wordt de operator
voor lidselectie genoemd, ook wel de puntoperator genoemd.
Er zijn geen spaties toegestaan tussen de naam van de variabele, de punt en de naam van het lid.
Om de waarde van de dag in de variabele vandaag in te stellen op
25, zou ik zoiets als dit doen. De naam van de variabele die
vandaag is, en dan zou ik zeggen punt, geen spaties tussen beide zijden.
En dan zou ik de naam van het element binnen de structuurdefinitie specificeren,
wat dag is.
En dan zou ik het toewijzen, net zoals ik elk ander geheel getal toewijs.
Ik zou de toewijzingsoperator gelijk
aan gebruiken, een letterlijke constante hier en de puntkomma.
Heel, heel eenvoudig. Als ik het jaar
wil toewijzen, zou ik zeggen vandaag. jaar en ik zou zeggen gelijk 2015 bijvoorbeeld.
En wanneer ik toegang wil tot de ledenwaarden.
Als ik bijvoorbeeld toegang zou willen hebben tot de lidwaarde van de maand om te zien of deze gelijk
is aan 12, zou ik nog steeds die puntsyntaxis gebruiken, die operator voor lidselectie.
U kunt dus de operator voor ledenselectie gebruiken om toegang te krijgen tot de ledenwaarden.
En wanneer u toegang krijgt
tot die lidvariabelen, kunt u ze gebruiken net zoals u andere variabelen gebruikt.
Je kunt ze gebruiken in rekenkundige bewerkingen als ze ints zijn.
U zou de regels van dat gegevenstype volgen.
Dus in dit geval kunnen we dat vergelijken met 12 door alleen
de is gelijk aan is in een if-statement te gebruiken.
En dan, bijvoorbeeld, als het gelijk was aan 12, zouden we kunnen zeggen dat volgende maand gelijk is aan 1.
Dat kan een lokale variabele zijn die we zouden toewijzen.
Laten we dus naar een voorbeeld kijken. Hier definiëren we een structuur genaamd date.
We hebben drie elementen, gehele getallen: maand, dag en jaar.
We weten dat we het definiëren omdat we het struct-sleutelwoord hebben en we hebben die accolades.
En merk dan ook op dat de rechter accolade een puntkomma heeft om de definitie te beëindigen.
Op dit moment is er geen geheugen toegewezen voor deze structuur.
In de volgende regel declareren we eigenlijk een variabele van
dat type, dus we wijzen nu geheugen toe voor een variabelenaam die
vandaag drie elementen bevat: maand, dag en jaar van het type int.
We kunnen gegevens toewijzen aan die drie elementen binnen die structuur
van vandaag door alleen die puntlidtoegang te gebruiken.
Dus vandaag. maand is gelijk aan negen, vandaag. dag is gelijk aan 25 en vandaag. jaar 2015.
Als we het vervolgens wilden afdrukken of toegang tot die gegevens wilden hebben, zouden we het op dezelfde manier openen
nadat we het hadden toegewezen. We zouden gewoon die ledenselectie gebruiken: vandaag. maand, vandaag.
dagelijks. jaar. En nogmaals, we kunnen er rekenkundige bewerkingen op uitvoeren omdat het een int is.
We zouden procent d gebruiken of als we het naar 2
willen formatteren, kunnen we procent 2I of procent 2D zeggen.
Dit is dus een vrij eenvoudige syntaxis,
heel gemakkelijk om structuren te maken en te definiëren en deze vervolgens
te gebruiken en vervolgens te openen met behulp van de puntlidselectie-operator.
Hoe zit het met structuren en uitdrukkingen?
Je zag net dat ik toegang had tot gegevens en een rekenkundige uitdrukking kon gebruiken en
het is niet anders.
Als het gaat om de evaluatie
van de uitdrukking, volgen structuurleden dezelfde regels als gewone variabelen.
Als je leden binnen die struct hebt die gehele getallen zijn, kun je
dezelfde regels toepassen als elk ander geheel getal.
U kunt optellen, aftrekken enzovoort toepassen. Als het een karakterbuffer is, kunt u
alleen de regels van karakterbuffers toepassen. Kun je karakterbuffers toevoegen en mintekens,
dat soort dingen, meestal niet.
Dus floats, doubles, alle verschillende datatypes, je
zou gewoon dezelfde regels volgen als je die leden in expressies gebruikt.
Dus hier is een voorbeeld.
Ik zeg vandaag. jaar gedeeld door honderd plus één.
Perfect geldig omdat jaar een int is, niet
anders dan het gebruik van een reguliere variabele van het type int.
U opent het gewoon op een andere manier door die operator voor ledenselectie te gebruiken.
Nu zijn er varianten. Er zijn verschillende manieren om de structuren te definiëren.
Het enige geweldige aan c is zijn flexibiliteit en met c
kun je een structuur op veel verschillende manieren definiëren. Het kan dus zijn dat u
een andere syntaxis ziet wanneer u een structuur definieert.
Het eerste voorbeeld dat ik je liet zien, is echt degene die je moet volgen. U moet altijd een tagnaam hebben
en u moet de structuur op één plaats van uw code definiëren en vervolgens variabelen
ervan in een andere declareren. Maar zoals het
is, is het erg flexibel. U kunt eigenlijk structuren definiëren en variabelen declareren in dezelfde regel.
En u kunt ook anonieme structuren of geen benoemde structuren definiëren.
Er is dus veel flexibiliteit. Het is geldig om een
variabele te declareren als onderdeel van een bepaalde structuur terwijl u de structuur feitelijk definieert.
Onderaan kan je de naam van de variabele zetten. Ik laat je zien hoe je dat doet.
Zet de variabelenaam of namen vóór de puntkomma aan het einde van de structuurdefinitie.
En u kunt ook waarden aan die variabelen toewijzen en initialiseren op de
normale manier waarop u variabelen toewijst. Dus laten we daar eens naar kijken.
Een variatie op het definiëren van een structeur door het te doen terwijl u het definieert,
kunt u een variabele declareren. Dus in dit geval hebben
we onze structdatum gedefinieerd, maar we hebben ook een variabele gemaakt met de naam vandaag.
Omdat aan het einde van de accolade rechts de naam voor de puntkomma staat, is dat
zowel de creatie van de variabele van het type date struct als de definitie van de struct date.
Dus in dit bovenstaande geval maakt u een
variabele van de structuur.
We noemen dat ook wel een instantie van de structuur. Het heet vandaag.
Het wordt tegelijkertijd verklaard dat de structuur is gedefinieerd.
Dus vandaag is een variabele van het type datum, we hebben het allemaal in één gedaan.
En je zou eigenlijk direct nadat je
de vandaag hebt gedaan, die variabelen kunnen initialiseren door
de haakjes te gebruiken en
dan te zeggen dat maand gelijk is aan vijf, dag gelijk is
aan enzovoort, net zoals je andere gehele getallen initialiseert.
Een andere manier om een structuur te creëren, is dat u
een naamloze structuur kunt maken. Dit is wat beperkter omdat je
er niet veel mee kunt doen.
Maar u hoeft niet echt een tagnaam op te geven.
Onthoud dat de tagnaam bovenaan staat, direct na het structwoord.
In de vorige voorbeelden was de tagnaam datum.
Maar u hoeft die datum niet op te geven.
Als alle variabelen van een bepaald structuurtype zijn gedefinieerd wanneer de structuur wordt gedefinieerd,
kan de naam worden weggelaten.
En wat dit echt betekent, is dat je de structuur maar één
keer en één keer gaat gebruiken.
Dus we kunnen gewoon zeggen
struct int dag, int jaar, int maand en
dan de variabele in hetzelfde declareren.
Maar u zult merken dat er geen tagnaam achter het struct-sleutelwoord staat.
Dit is slechts één structuur. We gaan één keer gebruiken,
dus we maken de variabele vandaag en dan gaan we hem nooit meer gebruiken.
En dat is eigenlijk het nadeel en de beperking.
Je wilt dit echt nooit doen, tenzij je een soort lokale structuur hebt die je een keer gebruikt.
Maar u kunt hier geen verdere voorbeelden van definiëren als u
de structuur op deze manier
definieert als een structuur zonder naam, een structuur zonder naam.
Alle variabelen van dit structuurtype die u in uw programma wilt hebben, moeten in één instructie worden gedefinieerd.
U kunt meer dan één variabele maken, u kunt de komma van vandaag gebruiken
en vervolgens een andere variabele, zodat u meerdere variabelen kunt maken.
U kunt meerdere variabelen initialiseren.
Maar deze manier is een beetje beperkt, want na
die variabele declaratie onderaan, kun je geen variabelen meer maken.
Er zijn dus drie manieren om verschillende structuren te definiëren.
Een manier is om de structuur met een tagnaam te definiëren
en de variabele niet te maken. U maakt de variabele in een apart geval wanneer het geheugen wordt toegewezen.
Een andere manier is om de variabele en de
structuur aan te maken en tegelijkertijd waar je een
tagnaam zou hebben en dat zou
je in staat stellen om andere instanties of andere variabelen van dat structtype later
in je programma te creëren of deze derde optie waar je zou
kunnen creëren een naamloze struct
zonder naam en alleen de variabele onderaan. En nogmaals, u kunt deze allemaal
initialiseren wanneer u de variabelen maakt met alleen de accolades enzovoort.
Dus nu structuren initialiseren.
Het initialiseren van structuren lijkt erg op het initialiseren van arrays.
De elementen worden weergegeven tussen een paar accolades, waarbij
elk element wordt gescheiden door een komma.
Echt geen nieuwe dingen om hier te leren.
De beginwaarden tussen de accolades moeten constante expressies zijn. U kunt geen
variabelen gebruiken, ze lijken op een array.
Hier maken we een vandaag variabele van het type
struct date, en we zeggen dat het eerste lid gelijk is aan
zeven, de tweede is twee en de derde is 2015, wat overeenkomt met de maand
dag in het jaar, want dat is de volgorde
hoe ze in de structuur zijn gedefinieerd.
Dus net als bij een array-initialisatie, kunnen
er minder waarden worden vermeld dan in de structuur zijn opgenomen.
U hoeft niet alle drie op te geven, u kunt er
gewoon twee opgeven en dat zou de maand en de dag initialiseren en
het jaar zou niet worden geïnitialiseerd.
Dus dit zou de datum bepalen. een. maand
tot 12 datum1. dag tot 10, maar het geeft tot op heden geen initiële waarde. jaar.
U kunt de namen van de leden ook specificeren in de initialisatielijst,
zodat u geen bestelling hoeft te hebben.
Je kunt ze in elke gewenste volgorde zetten en daar ben je niet afhankelijk van.
Dus je zou iets kunnen doen als . lid is gelijk
aan waarde en structuurdatum, datum één. Je zou kunnen zeggen dat puntmaand gelijk is aan 12.
Dus de initiële syntaxis hiervan is het lid binnen de accolades
plaatsen met de punt en dan alleen de waarde toewijzen, punt maand is gelijk
aan 12 komma punt datum is gelijk aan 10.
Je hebt die stip nodig. Die stip is belangrijk, dus vergeet die stip niet.
U hebt de instantie vóór de punt niet nodig.
Dus dit gaat gewoon het jaarlid van de
datumstructuurvariabele vandaag instellen op 2015 in dit
volgende voorbeeld.
Dus hier zeggen we gewoon, want onthoud dat je enkele van
de andere lidvariabelen kunt weglaten. En in dit geval geven we de maand
van de dag toe, dus we stellen het jaar gewoon in op 2015.
In het vorige geval hebben we eigenlijk het jaar weggelaten
en hebben we de maand en de datum respectievelijk op 12 en 10 gezet.
We kunnen ook opdrachten uitvoeren met samengestelde letterlijke termen.
Welnu, wat is dat precies, een samengestelde letterlijke.
U kunt een of meer waarden aan een structuur toewijzen in een enkele instructie
met behulp van wat bekend staat als een samengestelde letterlijke.
Ik denk dat dit alleen in C11 kan zijn.
Maar hier hebben we
vandaag, laten we aannemen dat we een struct date today-variabele
hebben gemaakt, en dan plaatsen we de struct date tussen haakjes.
En binnen de accolades zeggen we 9 komma 25 komma 2015.
En dit is een samengestelde letterlijke.
Deze verklaring kan overal in het programma verschijnen.
Dus in tegenstelling tot het daadwerkelijk initialiseren of toewijzen van waarden met behulp van
het puntlid, kun je dit overal in het programma plaatsen nadat je de
huidige structuur hebt geïnitialiseerd. Het is geen aangifteverklaring.
Dit is een samengestelde letterlijke opdracht.
De typecast-operator wordt gebruikt om de compiler het type van de expressie te vertellen.
Dus je hebt die dingen tussen haakjes nodig, dat is een cast, struct date.
De lijst met waarden volgt de cast
en moet worden toegewezen aan de leden van de structuur in die volgorde, het is volgordeafhankelijk.
Het wordt dus op dezelfde manier weergegeven alsof u een structuurvariabele initialiseert.
Nogmaals, het voordeel hiervan is
dat u niet elke lidvariabele afzonderlijk op afzonderlijke regels hoeft toe te wijzen.
Je kunt het allemaal in één regel doen en zeggen oké, dit is de nieuwe
waarde voor deze variabele vandaag.
U kunt ook waarden opgeven met behulp van de puntlidnotatie, zoals ik al zei.
Je zou het gewoon in één regel zoals deze of
op afzonderlijke regels moeten doen. En op deze manier lijkt het een beetje op de initialisatie,
maar je doet nog steeds de samengestelde letterlijke termen.
Het voordeel van deze aanpak is dat de argumenten in willekeurige volgorde kunnen
verschijnen, dus net als voorheen.
Nogmaals, de sleutel en het verschil van deze toewijzingen is dat het
niet gebeurt in de initialisatie, je doet
het ergens anders in het programma om nieuwe waarden aan dat type toe te wijzen.
Dus veel goede informatie in deze lezing.
We hebben het gehad over structs en hoe krachtig ze zijn en hoe we
verschillende elementen of verschillende variabelen in één naam kunnen groeperen.
Wij definiëren die structuur. Er zijn verschillende manieren om een structuur te definiëren.
En dan moeten we ook nog een variabele declareren.
Zodra we die variabele hebben, kunnen
we gegevens aan die structuur toewijzen met behulp van de puntlidselectie-operator.
En dan bespreken we ook enkele van de verschillende
notaties en verschillende manieren om dingen te doen, evenals initialisatie.
We gaan nogal wat structuren gebruiken.
Ik heb een paar uitdagingen die je zullen helpen vertrouwd te raken met deze syntaxis.
Maar dit is nog maar het begin van de structuur. We moeten het
ook hebben over geneste structuren, hoe je pointers en structuren
kunt gebruiken en dat soort dingen.
Dus veel succes dit wordt een leuke en spannende sectie. Dank u.