Strukturen i C er en brukerdefinert datatype som kan brukes til å gruppere elementer av muligens forskjellige typer i en enkelt type. De struct nøkkelord brukes til å definere strukturen i programmeringsspråket C. Elementene i strukturen kalles dens medlem og de kan være av hvilken som helst gyldig datatype.
C Strukturerklæring
Vi må deklarere struktur i C før vi bruker den i programmet vårt. I strukturdeklarasjon spesifiserer vi medlemsvariablene sammen med deres datatype. Vi kan bruke nøkkelordet struct for å erklære strukturen i C ved å bruke følgende syntaks:
Syntaks
struct structure_name { data_type member_name1; data_type member_name1; .... .... };> Syntaksen ovenfor kalles også en strukturmal eller strukturprototype, og det er ikke allokert noe minne til strukturen i deklarasjonen.
C Strukturdefinisjon
For å bruke struktur i programmet vårt, må vi definere forekomsten. Det kan vi gjøre ved å lage variabler av strukturtypen. Vi kan definere strukturvariabler ved å bruke to metoder:
1. Strukturvariabelerklæring med strukturmal
struct structure_name { data_type member_name1; data_type member_name1; .... .... } variable1, varaible2, ... ;> 2. Strukturvariabelerklæring etter strukturmal
// structure declared beforehand struct structure_name variable1, variable2 , .......;>
Tilgang strukturmedlemmer
Vi kan få tilgang til strukturmedlemmer ved å bruke ( . ) punktoperator.
Syntaks
structure_name.member1; strcuture_name.member2;>
I tilfellet hvor vi har en peker til strukturen, kan vi også bruke piloperatoren for å få tilgang til medlemmene.
Initialiser strukturmedlemmer
Strukturmedlemmer Kan ikke være initialisert med erklæringen. For eksempel mislykkes følgende C-program i kompileringen.
struct Point { int x = 0; // COMPILER ERROR: cannot initialize members here int y = 0; // COMPILER ERROR: cannot initialize members here };> Årsaken til feilen ovenfor er enkel. Når en datatype er deklarert, blir det ikke tildelt noe minne for den. Minne tildeles kun når variabler opprettes.
Vi kan initialisere strukturmedlemmer på tre måter som er som følger:
- Bruke Assignment Operator.
- Bruker initialiseringsliste.
- Bruker utpekt initialiseringsliste.
1. Initialisering ved hjelp av Assignment Operator
struct structure_name str; str.member1 = value1; str.member2 = value2; str.member3 = value3; . . .>
2. Initialisering ved hjelp av Initializer List
struct structure_name str = { value1, value2, value3 };> I denne typen initialisering blir verdiene tilordnet i sekvensiell rekkefølge slik de er deklarert i strukturmalen.
3. Initialisering ved hjelp av Designated Initializer List
Utpekt initialisering lar strukturmedlemmer initialiseres i hvilken som helst rekkefølge. Denne funksjonen er lagt til i C99-standarden.
struct structure_name str = { .member1 = value1, .member2 = value2, .member3 = value3 };> Designated Initialization støttes bare i C, men ikke i C++.
Eksempel på struktur i C
Følgende C-program viser hvordan du bruker strukturer
C
liste vs sett i java
// 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;> }> |
>
>Produksjon
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 for strukturer
De typedef nøkkelord brukes til å definere et alias for den allerede eksisterende datatypen. I strukturer må vi bruke nøkkelordet struct sammen med strukturnavnet for å definere variablene. Noen ganger øker dette lengden og kompleksiteten til koden. Vi kan bruke typedef til å definere et nytt kortere navn for strukturen.
Eksempel
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;> }> |
>
>Produksjon
var1.a = 20 var2.x = 314>
Nestede strukturer
C-språket lar oss sette inn en struktur i en annen som medlem. Denne prosessen kalles nesting og slike strukturer kalles nestede strukturer. Det er to måter vi kan bygge en struktur inn i en annen:
1. Innebygd struktur hekking
I denne metoden er strukturen som nestes også erklært inne i den overordnede strukturen.
Eksempel
struct parent { int member1; struct member_str member2 { int member_str1; char member_str2; ... } ... }> 2. Separat strukturhekking
I denne metoden deklareres to strukturer separat, og deretter blir medlemsstrukturen nestet inne i den overordnede strukturen.
Eksempel
struct member_str { int member_str1; char member_str2; ... } struct parent { int member1; struct member_str member2; ... }> En ting å merke seg her er at erklæringen om strukturen alltid bør være til stede før dens definisjon som et strukturmedlem. For eksempel erklæringen nedenfor er ugyldig ettersom struct memet ikke er definert når det er deklarert inne i den overordnede strukturen.
struct parent { struct mem a; }; struct mem { int var; };> Få tilgang til nestede medlemmer
Vi kan få tilgang til nestede medlemmer ved å bruke samme ( . ) punktoperator to ganger som vist:
str_parent.str_child .member;>
Eksempel på strukturhekking
C
polymorfisme i java
// 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;> }> |
>
>Produksjon
var1.a = 25 var1.b.x = 195 var1.b.c = A>
Strukturpeker i C
Vi kan definere en peker som peker på strukturen som enhver annen variabel. Slike pekere kalles vanligvis Strukturpekere . Vi kan få tilgang til medlemmene av strukturen pekt av strukturpekeren ved å bruke ( -> ) piloperator.
Eksempel på strukturpeker
C
// 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;> }> |
>
>Produksjon
1 2>
Selvrefererende strukturer
De selvrefererende strukturene i C er de strukturene som inneholder referanser til samme type som seg selv, dvs. de inneholder et medlem av typepekeren som peker til samme strukturtype.
Eksempel på selvrefererende strukturer
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->neste->mem1,> >ptr1->neste->mem2);> > >return> 0;> }> |
>
inkluderer c-programmering
>Produksjon
var2.mem1: 10 var2.mem2: 20>
Slike typer strukturer brukes i forskjellige datastrukturer som for å definere nodene til koblede lister, trær, etc.
C Strukturpolstring og pakking
Teknisk sett bør størrelsen på strukturen i C være summen av størrelsene til dens medlemmer. Men det er kanskje ikke sant i de fleste tilfeller. Grunnen til dette er strukturpolstring.
Strukturpolstring er konseptet med å legge til flere tomme byte i strukturen for naturlig å justere datamedlemmene i minnet. Det gjøres for å minimere CPU-lesesyklusene for å hente forskjellige datamedlemmer i strukturen.
Det er noen situasjoner der vi må pakke strukturen tett ved å fjerne de tomme bytene. I slike tilfeller bruker vi Strukturpakking. C-språket gir to måter for strukturpakking:
- Bruk av #pragma-pakke(1)
- Bruke __attribute((pakket))__
Eksempel på strukturpolstring og 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;> }> |
>
>Produksjon
Size of str1: 8 Size of str2: 5>
Som vi kan se, varierer størrelsen på strukturen når strukturpakking utføres.
For å vite mer om strukturpolstring og pakking, se denne artikkelen - Bitfelt brukes til å spesifisere lengden på strukturelementene i biter. Når vi vet maksimal lengde på medlemmet, kan vi bruke bitfelt for å spesifisere størrelsen og redusere minneforbruket.
Syntaks for bitfelt
struct structure_name { data_type member_name : width_of_bit-field; };> Eksempel på bitfelt
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;> }> |
>
>Produksjon
Size of Str1: 8 Size of Str2: 4>
Som vi kan se, reduseres størrelsen på strukturen når du bruker bitfeltet for å definere maksstørrelsen til medlemmet 'a'.
Bruk av struktur i C
C-strukturer brukes til følgende:
- Strukturen kan brukes til å definere de egendefinerte datatypene som kan brukes til å lage noen komplekse datatyper som datoer, klokkeslett, komplekse tall osv. som ikke finnes i språket.
- Den kan også brukes i dataorganisasjon hvor en stor mengde data kan lagres i ulike felt.
- Strukturer brukes til å lage datastrukturer som trær, lenkede lister, etc.
- De kan også brukes til å returnere flere verdier fra en funksjon.
Begrensninger for C-strukturer
I C-språk gir strukturer en metode for å pakke sammen data av forskjellige typer. En struktur er et nyttig verktøy for å håndtere en gruppe logisk relaterte dataelementer. Imidlertid har C-strukturer også noen begrensninger.
- Høyere minneforbruk: Det skyldes strukturpolstring. Ingen dataskjul: C-strukturer tillater ikke dataskjuling. Strukturelementer kan nås av enhver funksjon, hvor som helst i strukturens omfang. Funksjoner inne i strukturen: C-strukturer tillater ikke funksjoner inne i strukturen, så vi kan ikke tilby de tilknyttede funksjonene. Statiske medlemmer: C-struktur kan ikke ha statiske elementer inne i kroppen. Konstruksjonsoppretting i Structure: Strukturer i C kan ikke ha en konstruktør inne i Structures.
relaterte artikler
- C-strukturer vs C++-struktur
