De structuur in C is een door de gebruiker gedefinieerd gegevenstype dat kan worden gebruikt om items van mogelijk verschillende typen in één type te groeperen. De struct-trefwoord wordt gebruikt om de structuur in de programmeertaal C te definiëren. De items in de structuur worden its genoemd lid en ze kunnen van elk geldig gegevenstype zijn.
C Structuurverklaring
We moeten de structuur in C declareren voordat we deze in ons programma gebruiken. Bij structuurdeclaratie specificeren we de lidvariabelen samen met hun gegevenstype. We kunnen het sleutelwoord struct gebruiken om de structuur in C te declareren met behulp van de volgende syntaxis:
Syntaxis
struct structure_name { data_type member_name1; data_type member_name1; .... .... };> De bovenstaande syntaxis wordt ook wel een structuursjabloon of structuurprototype genoemd en er wordt geen geheugen toegewezen aan de structuur in de declaratie.
C Structuurdefinitie
Om structuur in ons programma te gebruiken, moeten we de instantie ervan definiëren. We kunnen dat doen door variabelen van het structuurtype te maken. We kunnen structuurvariabelen definiëren met behulp van twee methoden:
1. Structuurvariabeledeclaratie met structuursjabloon
struct structure_name { data_type member_name1; data_type member_name1; .... .... } variable1, varaible2, ... ;> 2. Structuurvariabeledeclaratie na structuursjabloon
// structure declared beforehand struct structure_name variable1, variable2 , .......;>
Toegang tot structuurleden
We hebben toegang tot structuurleden door gebruik te maken van de (.) puntoperator.
Syntaxis
structure_name.member1; strcuture_name.member2;>
In het geval dat we een verwijzing naar de structuur hebben, kunnen we ook de pijloperator gebruiken om toegang te krijgen tot de leden.
Initialiseer structuurleden
Structuur leden kan niet zijn geïnitialiseerd met de declaratie. Het volgende C-programma mislukt bijvoorbeeld bij de compilatie.
struct Point { int x = 0; // COMPILER ERROR: cannot initialize members here int y = 0; // COMPILER ERROR: cannot initialize members here };> De reden voor de bovenstaande fout is eenvoudig. Wanneer een datatype wordt gedeclareerd, wordt er geen geheugen voor toegewezen. Geheugen wordt alleen toegewezen wanneer variabelen worden gemaakt.
We kunnen structuurleden op 3 manieren initialiseren, namelijk:
- Toewijzingsoperator gebruiken.
- Initialisatielijst gebruiken.
- Gebruik van de aangewezen initialisatielijst.
1. Initialisatie met behulp van Assignment Operator
struct structure_name str; str.member1 = value1; str.member2 = value2; str.member3 = value3; . . .>
2. Initialisatie met behulp van Initialisatielijst
struct structure_name str = { value1, value2, value3 };> Bij dit type initialisatie worden de waarden toegewezen in de volgorde waarin ze in de structuursjabloon zijn gedeclareerd.
bin naar bcd
3. Initialisatie met behulp van de aangewezen initialisatielijst
Met Designated Initialization kunnen structuurelementen in willekeurige volgorde worden geïnitialiseerd. Deze functie is toegevoegd in de C99-standaard.
struct structure_name str = { .member1 = value1, .member2 = value2, .member3 = value3 };> De Designated Initialization wordt alleen ondersteund in C, maar niet in C++.
Voorbeeld van structuur in C
Het volgende C-programma laat zien hoe u structuren gebruikt
C
// C program to illustrate the use of structures> #include> > // declaring structure with name str1> struct> str1 {> >int> i;> >char> c;> >float> f;> >char> s[30];> };> > // declaring structure with name str2> struct> str2 {> >int> ii;> >char> cc;> >float> ff;> } var;>// variable declaration with structure template> > // Driver code> int> main()> {> >// variable declaration after structure template> >// initialization with initializer list and designated> >// initializer list> >struct> str1 var1 = { 1,>'A'>, 1.00,>'techcodeview.com'> },> >var2;> >struct> str2 var3 = { .ff = 5.00, .ii = 5, .cc =>'a'> };> > >// copying structure using assignment operator> >var2 = var1;> > >printf>(>'Struct 1:
i = %d, c = %c, f = %f, s = %s
'>,> >var1.i, var1.c, var1.f, var1.s);> >printf>(>'Struct 2:
i = %d, c = %c, f = %f, s = %s
'>,> >var2.i, var2.c, var2.f, var2.s);> >printf>(>'Struct 3
i = %d, c = %c, f = %f
'>, var3.ii,> >var3.cc, var3.ff);> > >return> 0;> }> |
>
>Uitvoer
Struct 1: i = 1, c = A, f = 1.000000, s = techcodeview.com Struct 2: i = 1, c = A, f = 1.000000, s = techcodeview.com Struct 3 i = 5, c = a, f = 5.000000>
typedef voor structuren
De typedef trefwoord wordt gebruikt om een alias te definiëren voor het reeds bestaande gegevenstype. In structuren moeten we het sleutelwoord struct samen met de structuurnaam gebruiken om de variabelen te definiëren. Soms vergroot dit de lengte en complexiteit van de code. We kunnen typedef gebruiken om een nieuwe, kortere naam voor de structuur te definiëren.
Voorbeeld
C
// C Program to illustrate the use of typedef with> // structures> #include> > // defining structure> struct> str1 {> >int> a;> };> > // defining new name for str1> typedef> struct> str1 str1;> > // another way of using typedef with structures> typedef> struct> str2 {> >int> x;> } str2;> > int> main()> {> >// creating structure variables using new names> >str1 var1 = { 20 };> >str2 var2 = { 314 };> > >printf>(>'var1.a = %d
'>, var1.a);> >printf>(>'var2.x = %d'>, var2.x);> > >return> 0;> }> |
>
>Uitvoer
var1.a = 20 var2.x = 314>
Geneste structuren
Met C-taal kunnen we als lid de ene structuur in de andere invoegen. Dit proces wordt nesten genoemd en dergelijke structuren worden geneste structuren genoemd. Er zijn twee manieren waarop we de ene structuur in de andere kunnen nesten:
1. Nesten van ingebedde structuren
Bij deze methode wordt de geneste structuur ook binnen de bovenliggende structuur gedeclareerd.
Voorbeeld
struct parent { int member1; struct member_str member2 { int member_str1; char member_str2; ... } ... }> 2. Aparte structuurnesten
Bij deze methode worden twee structuren afzonderlijk gedeclareerd, waarna de ledenstructuur binnen de bovenliggende structuur wordt genest.
Voorbeeld
struct member_str { int member_str1; char member_str2; ... } struct parent { int member1; struct member_str member2; ... }> Eén ding om op te merken is dat de declaratie van de structuur altijd aanwezig moet zijn vóór de definitie ervan als structuurlid. Bijvoorbeeld de onderstaande verklaring is ongeldig omdat de struct mem niet wordt gedefinieerd wanneer deze binnen de bovenliggende structuur wordt gedeclareerd.
struct parent { struct mem a; }; struct mem { int var; };> Toegang tot geneste leden
We hebben toegang tot geneste leden door twee keer dezelfde (.) puntoperator te gebruiken, zoals weergegeven:
str_parent.str_child .member;>
Voorbeeld van structuurnesten
C
// C Program to illustrate structure nesting along with> // forward declaration> #include> > // child structure declaration> struct> child {> >int> x;> >char> c;> };> > // parent structure declaration> struct> parent {> >int> a;> >struct> child b;> };> > // driver code> int> main()> {> >struct> parent var1 = { 25, 195,>'A'> };> > >// accessing and printing nested members> >printf>(>'var1.a = %d
'>, var1.a);> >printf>(>'var1.b.x = %d
'>, var1.b.x);> >printf>(>'var1.b.c = %c'>, var1.b.c);> > >return> 0;> }> |
>
>Uitvoer
turbo c++ downloaden
var1.a = 25 var1.b.x = 195 var1.b.c = A>
Structuuraanwijzer in C
We kunnen een pointer definiëren die naar de structuur verwijst, net als elke andere variabele. Dergelijke aanwijzingen worden over het algemeen genoemd Structuuraanwijzers . We kunnen toegang krijgen tot de leden van de structuur waarnaar wordt verwezen door de structuuraanwijzer met behulp van de ( -> ) pijloperator.
Voorbeeld van structuuraanwijzer
C
Hoe tekenreeks naar Java met gehele getallen te converteren
// C program to illustrate the structure pointer> #include> > // structure declaration> struct> Point {> >int> x, y;> };> > int> main()> {> >struct> Point str = { 1, 2 };> > >// p2 is a pointer to structure p1> >struct> Point* ptr = &str;> > >// Accessing structure members using structure pointer> >printf>(>'%d %d'>, ptr->x, ptr->y);> > >return> 0;> }> |
>
>Uitvoer
1 2>
Zelfreferentiële structuren
De zelfreferentiële structuren in C zijn die structuren die verwijzingen bevatten naar hetzelfde type als zijzelf, dat wil zeggen dat ze een lid van de typepointer bevatten die naar hetzelfde structuurtype verwijst.
Voorbeeld van zelfreferentiële structuren
struct structure_name { data_type member1; data_type member2; struct structure_name* str; }> C
// C program to illustrate the self referential structures> #include> > // structure template> typedef> struct> str {> >int> mem1;> >int> mem2;> >struct> str* next;> }str;> > // driver code> int> main()> {> >str var1 = { 1, 2, NULL };> >str var2 = { 10, 20, NULL };> > >// assigning the address of var2 to var1.next> >var1.next = &var2;> > >// pointer to var1> >str *ptr1 = &var1;> > >// accessing var2 members using var1> >printf>(>'var2.mem1: %d
var2.mem2: %d'>, ptr1->volgende->mem1,> >ptr1->volgende->mem2);> > >return> 0;> }> |
>
>Uitvoer
var2.mem1: 10 var2.mem2: 20>
Dergelijke soorten structuren worden gebruikt in verschillende datastructuren, zoals het definiëren van de knooppunten van gekoppelde lijsten, bomen, enz.
C-structuur opvulling en verpakking
Technisch gezien zou de grootte van de structuur in C de som moeten zijn van de afmetingen van zijn leden. Maar voor de meeste gevallen is dit misschien niet waar. De reden hiervoor is Structure Padding.
Structuur vulling is het concept van het toevoegen van meerdere lege bytes aan de structuur om de gegevensleden in het geheugen op natuurlijke wijze uit te lijnen. Dit wordt gedaan om de CPU-leescycli te minimaliseren om verschillende gegevensleden in de structuur op te halen.
Er zijn enkele situaties waarin we de structuur stevig moeten inpakken door de lege bytes te verwijderen. In dergelijke gevallen gebruiken we Structuur verpakking. C-taal biedt twee manieren voor structuurverpakking:
- #pragma-pakket(1) gebruiken
- Gebruik __attribuut((verpakt))__
Voorbeeld van structuuropvulling en pakking
C
// C program to illustrate structure padding and packing> #include> > // structure with padding> struct> str1 {> >char> c;> >int> i;> };> > struct> str2 {> >char> c;> >int> i;> } __attribute((packed)) __;>// using structure packing> > // driver code> int> main()> {> > >printf>(>'Size of str1: %d
'>,>sizeof>(>struct> str1));> >printf>(>'Size of str2: %d
'>,>sizeof>(>struct> str2));> >return> 0;> }> |
>
>Uitvoer
Size of str1: 8 Size of str2: 5>
Zoals we kunnen zien, varieert de grootte van de structuur wanneer structuurpakking wordt uitgevoerd.
Raadpleeg dit artikel voor meer informatie over structuuropvulling en -verpakking. Bitvelden worden gebruikt om de lengte van de structuurleden in bits op te geven. Wanneer we de maximale lengte van het lid kennen, kunnen we bitvelden gebruiken om de grootte te specificeren en het geheugengebruik te verminderen.
Syntaxis van bitvelden
struct structure_name { data_type member_name : width_of_bit-field; };> Voorbeeld van bitvelden
C
// C Program to illustrate bit fields in structures> #include> > // declaring structure for reference> struct> str1 {> >int> a;> >char> c;> };> > // structure with bit fields> struct> str2 {> >int> a : 24;>// size of 'a' is 3 bytes = 24 bits> >char> c;> };> > // driver code> int> main()> {> >printf>(>'Size of Str1: %d
Size of Str2: %d'>,> >sizeof>(>struct> str1),>sizeof>(>struct> str2));> >return> 0;> }> |
livecricket.is
>
>Uitvoer
Size of Str1: 8 Size of Str2: 4>
Zoals we kunnen zien, wordt de grootte van de structuur verkleind wanneer het bitveld wordt gebruikt om de maximale grootte van het lid ‘a’ te definiëren.
Gebruik van structuur in C
C-structuren worden gebruikt voor het volgende:
- De structuur kan worden gebruikt om de aangepaste gegevenstypen te definiëren die kunnen worden gebruikt om enkele complexe gegevenstypen te creëren, zoals datums, tijd, complexe getallen, enz., die niet in de taal aanwezig zijn.
- Het kan ook worden gebruikt bij het organiseren van gegevens, waarbij een grote hoeveelheid gegevens in verschillende velden kan worden opgeslagen.
- Structuren worden gebruikt om datastructuren te creëren, zoals bomen, gekoppelde lijsten, enz.
- Ze kunnen ook worden gebruikt voor het retourneren van meerdere waarden uit een functie.
Beperkingen van C-structuren
In de C-taal bieden structuren een methode voor het samenpakken van gegevens van verschillende typen. Een structuur is een handig hulpmiddel om een groep logisch gerelateerde gegevensitems te verwerken. C-structuren hebben echter ook enkele beperkingen.
- Hoger geheugenverbruik: dit komt door structuuropvulling. Geen gegevens verbergen: C-structuren staan het verbergen van gegevens niet toe. Structuurleden zijn toegankelijk voor elke functie, overal binnen het bereik van de structuur. Functies binnen de structuur: C-structuren staan geen functies binnen de structuur toe, dus we kunnen de bijbehorende functies niet leveren. Statische leden: C-structuur kan geen statische leden in het lichaam hebben. Constructie maken in Structuur: Structuren in C kunnen geen constructor binnen Structuren hebben.
gerelateerde artikelen
- C-structuren versus C++-structuur