Struktūra C ir lietotāja definēts datu tips, ko var izmantot, lai grupētu iespējami dažādu veidu vienumus vienā tipā. The struktūras atslēgvārds tiek izmantots, lai definētu struktūru C programmēšanas valodā. Struktūras vienumus sauc par tā biedrs un tiem var būt jebkurš derīgs datu tips.
C Struktūras deklarācija
Pirms tās izmantošanas programmā C ir jādeklarē struktūra. Struktūras deklarācijā mēs norādām tās dalībnieku mainīgos kopā ar to datu tipu. Mēs varam izmantot atslēgvārdu struct, lai deklarētu struktūru C, izmantojot šādu sintaksi:
Sintakse
struct structure_name { data_type member_name1; data_type member_name1; .... .... };> Iepriekš minēto sintaksi sauc arī par struktūras veidni vai struktūras prototipu, un deklarācijā struktūrai netiek piešķirta atmiņa.
C Struktūras definīcija
Lai programmā izmantotu struktūru, mums ir jādefinē tās gadījums. Mēs to varam izdarīt, izveidojot struktūras tipa mainīgos. Mēs varam definēt struktūras mainīgos, izmantojot divas metodes:
1. Struktūras mainīgā deklarācija ar struktūras veidni
struct structure_name { data_type member_name1; data_type member_name1; .... .... } variable1, varaible2, ... ;> 2. Struktūras mainīgā deklarācija pēc struktūras veidnes
// structure declared beforehand struct structure_name variable1, variable2 , .......;>
Piekļuves struktūras locekļi
Mēs varam piekļūt struktūras dalībniekiem, izmantojot ( . ) punktu operators.
Sintakse
structure_name.member1; strcuture_name.member2;>
Gadījumā, ja mums ir rādītājs uz struktūru, mēs varam arī izmantot bultiņu operatoru, lai piekļūtu dalībniekiem.
Inicializēt struktūras dalībniekus
Struktūras dalībnieki nevar būt inicializēts ar deklarāciju. Piemēram, šādai C programmai kompilācijā neizdodas.
struct Point { int x = 0; // COMPILER ERROR: cannot initialize members here int y = 0; // COMPILER ERROR: cannot initialize members here };> Iepriekš minētās kļūdas iemesls ir vienkāršs. Kad datu tips ir deklarēts, tam netiek piešķirta atmiņa. Atmiņa tiek piešķirta tikai tad, kad ir izveidoti mainīgie.
Mēs varam inicializēt struktūras elementus 3 veidos, kas ir šādi:
- Izmantojot uzdevumu operatoru.
- Inicializētāju saraksta izmantošana.
- Izmantojot norādīto inicializatoru sarakstu.
1. Inicializācija, izmantojot piešķiršanas operatoru
struct structure_name str; str.member1 = value1; str.member2 = value2; str.member3 = value3; . . .>
2. Inicializācija, izmantojot inicializatoru sarakstu
struct structure_name str = { value1, value2, value3 };> Šāda veida inicializācijā vērtības tiek piešķirtas secīgā secībā, kā tās ir deklarētas struktūras veidnē.
3. Inicializācija, izmantojot norādīto inicializētāju sarakstu
Izraudzītā inicializācija ļauj inicializēt struktūras elementus jebkurā secībā. Šī funkcija ir pievienota C99 standartā.
struct structure_name str = { .member1 = value1, .member2 = value2, .member3 = value3 };> Norādītā inicializācija tiek atbalstīta tikai C valodā, bet ne C++.
Struktūras piemērs C
Sekojošā C programma parāda, kā izmantot struktūras
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;> }> |
>
>Izvade
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 Struktūrām
The typedef atslēgvārds tiek izmantots, lai definētu aizstājvārdu jau esošajam datu tipam. Struktūrās mums ir jāizmanto atslēgvārds struct kopā ar struktūras nosaukumu, lai definētu mainīgos. Dažreiz tas palielina koda garumu un sarežģītību. Mēs varam izmantot typedef, lai definētu kādu jaunu, īsāku struktūras nosaukumu.
Piemērs
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;> }> |
>
>Izvade
var1.a = 20 var2.x = 314>
Ligzdotas struktūras
C valoda ļauj mums ievietot vienu struktūru citā kā dalībnieku. Šo procesu sauc par ligzdošanu, un šādas struktūras sauc par ligzdotām struktūrām. Ir divi veidi, kā mēs varam ievietot vienu struktūru citā:
kas ir myspace
1. Iegultās struktūras ligzdošana
Šajā metodē ligzdotā struktūra tiek deklarēta arī vecākstruktūrā.
Piemērs
struct parent { int member1; struct member_str member2 { int member_str1; char member_str2; ... } ... }> 2. Atsevišķa struktūras ligzdošana
Šajā metodē divas struktūras tiek deklarētas atsevišķi, un pēc tam dalībnieku struktūra tiek ligzdota vecākstruktūrā.
Piemērs
struct member_str { int member_str1; char member_str2; ... } struct parent { int member1; struct member_str member2; ... }> Viena lieta, kas jāņem vērā, ir tāda, ka struktūras deklarācijai vienmēr jābūt iekļautai pirms tās definīcijas kā struktūras dalībnieks. Piemēram, zemāk norādītā deklarācija nav derīga jo struct mem nav definēts, kad tas tiek deklarēts vecākstruktūrā.
struct parent { struct mem a; }; struct mem { int var; };> Piekļuve ligzdotajiem dalībniekiem
Mēs varam piekļūt ligzdotajiem dalībniekiem, izmantojot to pašu (. ) punktu operatoru divas reizes, kā parādīts:
str_parent.str_child .member;>
Struktūras ligzdošanas piemērs
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;> }> |
>
>Izvade
var1.a = 25 var1.b.x = 195 var1.b.c = A>
Struktūras rādītājs C
Mēs varam definēt rādītāju, kas norāda uz struktūru tāpat kā jebkurš cits mainīgais. Šādas norādes parasti sauc Struktūras norādes . Mēs varam piekļūt struktūras dalībniekiem, uz kuriem norāda struktūras rādītājs, izmantojot ( -> ) bultiņas operators.
Struktūras rādītāja piemērs
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;> }> |
>
>Izvade
1 2>
Pašreferences struktūras
Pašatsauces struktūras C ir tās struktūras, kurās ir atsauces uz tādu pašu tipu kā pašas, t.i., tajās ir tipa rādītāja elements, kas norāda uz to pašu struktūras tipu.
Pašreferences struktūru piemērs
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->nākamais->mem1,> >ptr1->nākamais->mem2);>> return> 0;> }> |
>
>Izvade
var2.mem1: 10 var2.mem2: 20>
Šāda veida struktūras tiek izmantotas dažādās datu struktūrās, piemēram, lai definētu saistīto sarakstu mezglus, kokus utt.
C Struktūras polsterējums un iepakošana
Tehniski struktūras lielumam C ir jābūt tās locekļu izmēru summai. Bet vairumā gadījumu tā var nebūt taisnība. Iemesls tam ir struktūras polsterējums.
Struktūras polsterējums ir koncepcija par vairāku tukšu baitu pievienošanu struktūrā, lai dabiski saskaņotu datu elementus atmiņā. Tas tiek darīts, lai samazinātu CPU lasīšanas ciklus, lai izgūtu dažādus datu elementus struktūrā.
java un šūpoles
Dažās situācijās mums ir nepieciešams cieši iesaiņot struktūru, noņemot tukšos baitus. Šādos gadījumos mēs izmantojam Struktūras iepakošana. C valoda nodrošina divus struktūras pakotnes veidus:
- #pragma pakotnes(1) izmantošana
- Izmantojot __atribūtu((iesaiņots))__
Struktūras polsterējuma un iepakošanas piemērs
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;> }> |
>
>Izvade
Size of str1: 8 Size of str2: 5>
Kā redzam, veicot struktūras iepakošanu, struktūras izmērs ir dažāds.
Lai uzzinātu vairāk par struktūras polsterējumu un iepakošanu, skatiet šo rakstu — bitu lauki tiek izmantoti, lai norādītu struktūras elementu garumu bitos. Kad mēs zinām maksimālo dalībnieka garumu, mēs varam izmantot bitu laukus, lai norādītu izmēru un samazinātu atmiņas patēriņu.
Bitu lauku sintakse
struct structure_name { data_type member_name : width_of_bit-field; };> Bitu lauku piemērs
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;> }> |
>
>Izvade
Size of Str1: 8 Size of Str2: 4>
Kā redzam, struktūras lielums tiek samazināts, izmantojot bitu lauku, lai definētu biedra “a” maksimālo izmēru.
Struktūras izmantošana C
C struktūras tiek izmantotas šādiem nolūkiem:
- Struktūru var izmantot, lai definētu pielāgotus datu tipus, kurus var izmantot, lai izveidotu dažus sarežģītus datu tipus, piemēram, datumus, laiku, kompleksos skaitļus utt., kas nav atrodami valodā.
- To var izmantot arī datu organizēšanā, kur dažādos laukos var uzglabāt lielu datu apjomu.
- Struktūras tiek izmantotas, lai izveidotu datu struktūras, piemēram, kokus, saistītos sarakstus utt.
- Tos var izmantot arī vairāku vērtību atgriešanai no funkcijas.
C struktūru ierobežojumi
C valodā struktūras nodrošina metodi dažādu veidu datu iesaiņošanai. Struktūra ir noderīgs rīks, lai apstrādātu loģiski saistītu datu vienumu grupu. Tomēr C struktūrām ir arī daži ierobežojumi.
- Lielāks atmiņas patēriņš: tas ir saistīts ar struktūras polsterējumu. Nav datu slēpšanas: C struktūras neļauj slēpt datus. Struktūras locekļiem var piekļūt jebkura funkcija jebkurā struktūras darbības jomā. Funkcijas konstrukcijā: C struktūras neļauj veikt funkcijas struktūrā, tāpēc mēs nevaram nodrošināt saistītās funkcijas. Statiskie elementi: C struktūras korpusā nedrīkst būt statiski elementi. Konstrukciju izveide programmā Structure: konstrukcijām C valodā nevar būt konstruktors konstrukciju iekšpusē.
Saistītie raksti
- C struktūras pret C++ struktūru