L'estructura en C és un tipus de dades definit per l'usuari que es pot utilitzar per agrupar elements de possiblement diferents tipus en un sol tipus. El paraula clau struct s'utilitza per definir l'estructura en el llenguatge de programació C. Els elements de l'estructura s'anomenen seu membre i poden ser de qualsevol tipus de dades vàlids.
C Declaració d'estructura
Hem de declarar l'estructura en C abans d'utilitzar-la al nostre programa. A la declaració d'estructura, especifiquem les seves variables membres juntament amb el seu tipus de dades. Podem utilitzar la paraula clau struct per declarar l'estructura en C utilitzant la sintaxi següent:
Sintaxi
struct structure_name { data_type member_name1; data_type member_name1; .... .... };> La sintaxi anterior també s'anomena plantilla d'estructura o prototip d'estructura i no s'assigna memòria a l'estructura a la declaració.
C Definició de l'estructura
Per utilitzar l'estructura al nostre programa, hem de definir la seva instància. Ho podem fer creant variables del tipus d'estructura. Podem definir variables d'estructura mitjançant dos mètodes:
1. Declaració de variables d'estructura amb plantilla d'estructura
struct structure_name { data_type member_name1; data_type member_name1; .... .... } variable1, varaible2, ... ;> 2. Declaració de variables d'estructura després de la plantilla d'estructura
// structure declared beforehand struct structure_name variable1, variable2 , .......;>
Membres de l'estructura d'accés
Podem accedir als membres de l'estructura mitjançant l' ( . ) operador de punts.
Sintaxi
structure_name.member1; strcuture_name.member2;>
En el cas que tinguem un punter a l'estructura, també podem utilitzar l'operador de fletxa per accedir als membres.
Inicialitzar els membres de l'estructura
Membres de l'estructura no pot ser inicialitzat amb la declaració. Per exemple, el següent programa C falla en la compilació.
struct Point { int x = 0; // COMPILER ERROR: cannot initialize members here int y = 0; // COMPILER ERROR: cannot initialize members here };> El motiu de l'error anterior és senzill. Quan es declara un tipus de dades, no s'hi assigna cap memòria. La memòria només s'assigna quan es creen variables.
Podem inicialitzar els membres de l'estructura de 3 maneres, que són les següents:
- Utilitzant l'operador d'assignació.
- Utilitzant la llista d'inicialitzadors.
- Ús de la llista d'inicialitzadors designats.
1. Inicialització mitjançant Assignment Operator
struct structure_name str; str.member1 = value1; str.member2 = value2; str.member3 = value3; . . .>
2. Inicialització mitjançant la llista d'inicialitzadors
struct structure_name str = { value1, value2, value3 };> En aquest tipus d'inicialització, els valors s'assignen en ordre seqüencial tal com es declaren a la plantilla d'estructura.
3. Inicialització mitjançant la llista d'inicialitzadors designats
La inicialització designada permet inicialitzar els membres de l'estructura en qualsevol ordre. Aquesta característica s'ha afegit a l'estàndard C99.
struct structure_name str = { .member1 = value1, .member2 = value2, .member3 = value3 };> La inicialització designada només s'admet en C però no en C++.
Exemple d'estructura en C
El programa C següent mostra com utilitzar estructures
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;> }> |
>
>Sortida
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 per a Estructures
El typedef La paraula clau s'utilitza per definir un àlies per al tipus de dades ja existent. A les estructures, hem d'utilitzar la paraula clau struct juntament amb el nom de l'estructura per definir les variables. De vegades, això augmenta la longitud i la complexitat del codi. Podem utilitzar el typedef per definir un nou nom més curt per a l'estructura.
Exemple
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;> }> |
>
>Sortida
var1.a = 20 var2.x = 314>
Estructures imbricades
El llenguatge C ens permet inserir una estructura en una altra com a membre. Aquest procés s'anomena nidificació i aquestes estructures s'anomenen estructures imbricades. Hi ha dues maneres en què podem niar una estructura en una altra:
1. Nidificació d'estructures incrustades
En aquest mètode, l'estructura que s'està imbricant també es declara dins de l'estructura pare.
Exemple
struct parent { int member1; struct member_str member2 { int member_str1; char member_str2; ... } ... }> 2. Nidificació d'estructures separades
En aquest mètode, es declaren dues estructures per separat i després l'estructura dels membres s'imbrica dins de l'estructura pare.
Exemple
struct member_str { int member_str1; char member_str2; ... } struct parent { int member1; struct member_str member2; ... }> Una cosa a tenir en compte aquí és que la declaració de l'estructura sempre hauria d'estar present abans de la seva definició com a membre de l'estructura. Per exemple, el la declaració següent no és vàlida ja que l'estructura mem no es defineix quan es declara dins de l'estructura pare.
struct parent { struct mem a; }; struct mem { int var; };> Accés a membres nius
Podem accedir als membres imbricats utilitzant el mateix operador de punts ( . ) dues vegades com es mostra:
str_parent.str_child .member;>
Exemple de nidificació d'estructures
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;> }> |
>
com funciona un ordinador
>Sortida
var1.a = 25 var1.b.x = 195 var1.b.c = A>
Estructura del punter en C
Podem definir un punter que apunta a l'estructura com qualsevol altra variable. Aquests indicadors s'anomenen generalment Apuntadors d'estructura . Podem accedir als membres de l'estructura apuntats pel punter de l'estructura mitjançant l' ( -> ) operador de fletxa.
Exemple de punter d'estructura
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;> }> |
>
>Sortida
1 2>
Estructures autoreferencials
Les estructures autoreferencials en C són aquelles estructures que contenen referències al mateix tipus que ells mateixos, és a dir, contenen un membre del punter de tipus que apunta al mateix tipus d'estructura.
Exemple d'estructures autorreferencials
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->següent->mem1,>>> return> 0;> }> |
>
>Sortida
var2.mem1: 10 var2.mem2: 20>
Aquest tipus d'estructures s'utilitzen en diferents estructures de dades, com ara definir els nodes de llistes enllaçades, arbres, etc.
Encoixinat i embalatge de l'estructura C
Tècnicament, la mida de l'estructura en C hauria de ser la suma de les mides dels seus membres. Però pot ser que no sigui cert per a la majoria dels casos. El motiu d'això és el farciment d'estructura.
Encoixinat de l'estructura és el concepte d'afegir diversos bytes buits a l'estructura per alinear de manera natural els membres de dades a la memòria. Es fa per minimitzar els cicles de lectura de la CPU per recuperar diferents membres de dades de l'estructura.
Hi ha algunes situacions en què hem d'empaquetar l'estructura amb força eliminant els bytes buits. En aquests casos, fem servir Estructura d'embalatge. El llenguatge C ofereix dues maneres d'empaquetar l'estructura:
- Utilitzant el paquet #pragma(1)
- Utilitzant __attribute((empaquetat))__
Exemple de farciment i embalatge d'estructura
C
com convertir de cadena a int
// 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;> }> |
>
>Sortida
Size of str1: 8 Size of str2: 5>
Com podem veure, la mida de l'estructura varia quan es realitza l'embalatge de l'estructura.
Per obtenir més informació sobre l'empaquetament i l'empaquetament de l'estructura, consulteu aquest article: els camps de bits s'utilitzen per especificar la longitud dels membres de l'estructura en bits. Quan coneixem la longitud màxima del membre, podem utilitzar camps de bits per especificar la mida i reduir el consum de memòria.
Sintaxi dels camps de bits
struct structure_name { data_type member_name : width_of_bit-field; };> Exemple de camps de bits
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;> }> |
>
>Sortida
Size of Str1: 8 Size of Str2: 4>
Com podem veure, la mida de l'estructura es redueix quan s'utilitza el camp de bits per definir la mida màxima del membre 'a'.
Usos de l'estructura a C
Les estructures C s'utilitzen per al següent:
- L'estructura es pot utilitzar per definir els tipus de dades personalitzats que es poden utilitzar per crear alguns tipus de dades complexos com ara dates, hora, nombres complexos, etc. que no estan presents a l'idioma.
- També es pot utilitzar en l'organització de dades on es poden emmagatzemar una gran quantitat de dades en diferents camps.
- Les estructures s'utilitzen per crear estructures de dades com ara arbres, llistes enllaçades, etc.
- També es poden utilitzar per retornar diversos valors d'una funció.
Limitacions de les estructures C
En llenguatge C, les estructures proporcionen un mètode per empaquetar dades de diferents tipus. Una estructura és una eina útil per gestionar un grup d'elements de dades relacionats lògicament. Tanmateix, les estructures C també tenen algunes limitacions.
- Major consum de memòria: es deu al farciment de l'estructura. Sense ocultació de dades: les estructures C no permeten ocultar dades. Es pot accedir als membres de l'estructura des de qualsevol funció, en qualsevol lloc de l'àmbit de l'estructura. Funcions dins de l'estructura: les estructures C no permeten funcions dins de l'estructura, de manera que no podem proporcionar les funcions associades. Membres estàtics: l'estructura C no pot tenir membres estàtics dins del seu cos. Creació de construccions a Structure: les estructures en C no poden tenir un constructor dins d'Estructures.
Articles relacionats
- Estructures C vs Estructura C++