C++ Structs Uitgelegd met een Praktisch Voorbeeld

Wat is een Struct in C++?

Een STRUCT is een C++‑datastructuur die gebruikt kan worden om elementen van verschillende datatypes samen op te slaan. In C++ is een structuur een user‑defined datatype. De structuur creëert een datatype voor het groeperen van items van verschillende datatypes onder één datatype.

Bijvoorbeeld:

Stel je moet informatie opslaan over iemand: hun naam, nationaliteit en leeftijd. Je kunt variabelen als name, citizenship en age aanmaken om de data apart op te slaan.

Toch moet je misschien in de toekomst informatie over veel personen opslaan. Dat betekent variabelen voor verschillende individuen: name1, citizenship1, age1, etc. Om dit te vermijden, is het beter om een struct te creëren.

In deze C++ tutorial leer je:

• Wat is een Struct in C++?
• Wanneer een Structuur gebruiken?
• C++ Struct Initialisatie
• Struct Instances Creëren
• Struct Members Benaderen
• Pointers naar Structuur
• Struct als Functie‑Argument
• Beperking van een C++ Structuur

Wanneer een Structuur Gebruiken?

Hier zijn enkele redenen om een structuur in C++ te gebruiken:

• Gebruik een struct wanneer je elementen van verschillende datatypes onder één datatype moet opslaan.
• C++ structs zijn een value‑type in plaats van een reference‑type. Gebruik een struct als je niet van plan bent je data na creatie te wijzigen.

C++ Struct Initialisatie

Om een C++ structuur te maken, gebruiken we het struct-keyword, gevolgd door een identificator. De identificator wordt de naam van de struct. Hier is de syntaxis voor het maken van een C++ struct:

Syntaxis:

struct struct_naam { // struct members } 

In de bovenstaande syntaxis hebben we het struct-keyword gebruikt. De struct_naam is de naam van de structuur.

De struct‑leden worden binnen accolades toegevoegd. Deze leden horen waarschijnlijk tot verschillende datatypes.

Bijvoorbeeld:

struct Person {
    char name[30];
    int citizenship;
    int age;
 } 

In het bovenstaande voorbeeld is Person een structuur met drie leden. De leden zijn name, citizenship en age. Een lid is van char‑datatype, de overige twee zijn integers. Wanneer een structuur wordt aangemaakt, wordt geen geheugen toegewezen. Geheugen wordt pas toegekend nadat een variabele aan de struct wordt toegevoegd.

Struct Instances Creëren

In het bovenstaande voorbeeld hebben we een struct genaamd Person gemaakt. We kunnen een struct‑variabele als volgt maken:

Person p; 

De p is een struct‑variabele van type Person. We kunnen deze variabele gebruiken om de leden van de struct te benaderen.

Struct Members Benaderen

Om de struct‑leden te benaderen, gebruiken we de instantie van de struct en de punt‑operator (.). Bijvoorbeeld, om het lid age van struct Person te benaderen:

p.age = 27; 

We hebben het lid age van struct Person benaderd via de instantie van de struct, p. We hebben de waarde van het lid age ingesteld op 27.

Voorbeeld 1:

#include <iostream>
using namespace std;
struct Person {
    int citizenship;
    int age;
};
int main(void) {
    struct Person p;
    p.citizenship = 1;
    p.age = 27;
    cout << "Person citizenship: " << p.citizenship << endl;
    cout << "Person age: " << p.age << endl;
    return 0;
 } 

Output:

Hier is een screenshot van de code:

Code‑uitleg:

1. Include de iostream header voor functies.
2. Include de std naamruimte om klassen zonder prefix te gebruiken.
3. Creëer een struct genaamd Person.
4. Begin van de struct‑body.
5. Creëer struct‑lid citizenship van type integer.
6. Creëer struct‑lid age van type integer.
7. Einde van de struct‑body.
8. Roep main() aan; programmeerlogica gaat in de body.
9. Creëer een instantie van struct Person met naam p.
10. Stel waarde van struct‑lid citizenship in op 1.
11. Stel waarde van struct‑lid age in op 27.
12. Print waarde van struct‑lid citizenship op console met tekst.
13. Print waarde van struct‑lid age op console met tekst.
14. Programma retourneert waarde bij succes.
15. Einde main().

Pointers naar Structuur

Het is mogelijk om een pointer te maken die naar een structuur wijst. Dit is vergelijkbaar met pointers naar native datatypes zoals int, float, double, etc. Let op dat een pointer in C++ een geheugenlocatie opslaat.

Voorbeeld 2:

#include <iostream>
using namespace std;
struct Length {
    int meters;
    float centimeters;
};
int main() {
    Length *ptr, l;
    ptr = &l;
    cout << "Enter meters: ";
    cin >> (*ptr).meters;
    cout << "Enter centimeters: ";
    cin >> (*ptr).centimeters;
    cout << "Length = " << (*ptr).meters << " meters " << (*ptr).centimeters << " centimeters";
    return 0;
 } 

Output:

Hier is een screenshot van de code:

Code‑uitleg:

1. Include iostream header.
2. Include std naamruimte.
3. Creëer struct genaamd Length.
4. Start van de body van struct Length.
5. Creëer struct‑lid meters van integer datatype.
6. Creëer struct‑lid centimeters van type integer.
7. Einde van de body van struct Length.
8. Roep main() aan.
9. Start van de body van main().
10. Creëer pointer variabele *ptr en normale variabele l van type Length.
11. Sla adres van variabele l op in pointer variabele.
12. Toon bericht op console, vraag gebruiker om waarde voor meters.
13. Lees waarde via toetsenbord. Het lid meters wordt hier benaderd via de pointer variabele.
14. Toon bericht op console, vraag gebruiker om waarde voor centimeters.
15. Lees waarde via toetsenbord. Het lid centimeters wordt hier benaderd via de pointer variabele.
16. Toon de uitgelezen waarden op console met tekst.
17. Programma retourneert waarde bij succes.
18. Einde van de body van main().

Struct als Functie‑Argument

Je kunt een struct aan een functie doorgeven als argument. Dit gebeurt op dezelfde manier als een gewoon argument. Struct‑variabelen kunnen ook aan een functie doorgegeven worden. Een goed voorbeeld is wanneer je de waarden van struct‑leden wilt tonen. Laten we dit demonstreren:

Voorbeeld 3:

#include<iostream>
using namespace std;
struct Person {
    int citizenship;
    int age;
};
void func(struct Person p);
int main() {
    struct Person p;
    p.citizenship = 1;
    p.age = 27;
    func(p);
    return 0;
 }
void func(struct Person p) {
    cout << " Person citizenship: " << p.citizenship<<endl;
    cout << " Person age: " << p.age;
 } 

Output:

Hier is een screenshot van de code:

Code‑uitleg:

1. Include iostream header in ons bestand. We kunnen dan functies gebruiken zonder fouten.
2. Include std naamruimte in ons programma om klassen te gebruiken. We hoeven de naamruimte niet aan te roepen.
3. Creëer een struct genaamd Person.
4. Start van de body van struct Person.
5. Creëer een lid van struct Person. Het lid heet citizenship en is van type integer.
6. Creëer een lid van struct Person. Het lid heet age en is van type integer.
7. Einde van de body van struct Person.
8. Creëer een functie die de instantie van struct Person, p, als argument neemt.
9. Roep de main functie aan. De { markeert het begin van de body van main().
10. Creëer een instantie van struct Person en geef het de naam p.
11. Benader struct‑lid citizenship via instantie p en wijs waarde 1 toe.
12. Benader struct‑lid age via instantie p en wijs waarde 27 toe.
13. Roep de functie aan en geef de instantie p als argument door.
14. De functie moet een waarde retourneren bij succes.
15. Einde van de body van main().
16. Creëer de body van de functie.
17. Start van de body van de functie.
18. Benader struct‑lid citizenship waarde en print op console met tekst.
19. Benader struct‑lid age waarde en print op console met tekst.
20. Einde van de functie‑body.

Beperking van een C++ Structuur

De volgende beperkingen gelden voor structuren:

• Het struct‑datatype kan niet behandeld worden als built‑in datatypes.
• Operators als +, -, en anderen kunnen niet op structuur‑variabelen gebruikt worden.
• Structuren ondersteunen geen data hiding. De leden van een structuur zijn toegankelijk voor elke functie ongeacht de scope.
• Static members kunnen niet binnen de structuur‑body gedeclareerd worden.
• Constructors kunnen niet binnen een structuur gemaakt worden.

Samenvatting:

• Een struct is een datastructuur die data‑elementen van verschillende typen opslaat.
• Waar een array elementen van een vergelijkbaar type opslaat, slaat een struct elementen van verschillende typen op.
• Een struct moet gebruikt worden wanneer de data‑elementen niet verwacht worden te veranderen.
• De leden van een struct worden benaderd met de punt‑operator (.).
• We moeten een instantie van de struct creëren.
• Om een C++ struct te maken, gebruiken we het struct-keyword.
• Pointers naar een struct worden op dezelfde manier gemaakt als pointers naar reguliere typen.
• Een struct kan als argument aan een functie doorgegeven worden op dezelfde manier als gewone functies.