Introduktion till kapslad struktur i C.
Alla programmeringsspråk har sitt eget sätt att definiera och beskriva strukturer. Så kapslade strukturer som namnet antyder i C är att definiera en struktur i en annan struktur. Alla medlemsvariabler kan definieras inuti en struktur och i sin tur kan strukturen vidare flyttas till en annan struktur. Variablerna i en struktur kan vara allt som normalt eller pekare eller vad som helst och kan placeras var som helst i strukturen.
Kapslad struktur kan nås på två sätt:
- Struktur inuti en struktur i C med hjälp av pekvariabeln.
- Struktur inuti en struktur i C med en normal variabel.
Syntax:
Följande är syntaxen för att skapa en kapslad struktur:
structure tagname_1
(
var_1;
var_2;
var_3;
.
.
.
.
var n;
structure tagname_2
(
var_1;
var_2;
var_3;
.
.
.
var_n;
), mem1
) mem2;
Arbeta med kapslad struktur i C.
Från ovanstående syntax kan vi dra slutsatsen att mem1-strukturen som är kapslad inuti medlem1-strukturen kommer att innehålla medlemmet eller variabeln som ska nås och alla kan nås på ett kapslat sätt med hjälp av. (punkt) operatör.
- mem2.mem1.var_1: Detta avser den första medlemmen i variabeln i strukturen tagname_1.
- mem2.mem1.var_2: Detta avser det andra medlemmet i variabeln för strukturen tagname_2.
Vi kommer att ta fler exempel för att få klarhet i hur syntaxen uppfyller funktionen i den kapslade strukturen.
Exempel 1
struct employee
(
struct man
(
char name (20);
int age;
char dob(10);
) d;
int empid;
char desg(10);
) emp;
I exemplet ovan definieras manstruktur inuti en anställdstruktur som är en kapslad struktur. Medlemmar inom den kapslade strukturen som är en man kan nås med syntax eller format nedan.
Som i det givna exemplet
- medarbetare.d. namn: Det berättar om namnet på mannen i anställdstrukturen.
- medarbetare.d. avdelning: Det kommer att berätta om åldern på mannen som anställd.
Det är viktigt att lägga märke till en sak som den här strukturen man inom anställdes struktur inte kan återanvändas vilket innebär att den inte kan kallas igen någonstans i hela koden eftersom den inte är självgenererad.
Istället kan en lösning för detta vara:
Vi kunde ha definierat strukturen utanför och sedan kunde ha deklarerat variabeln inuti strukturen var vi vill komma åt den genom hela koden.
Exempel # 2
Struct man
(
char name(20);
int age;
char dob (10);
);
Denna struktur kan också återanvändas av den yttre strukturen.
struct employee
(
struct man info;
int id;
char desg (10);
)
Fördelen med att använda denna typ av strukturdeklaration är att vi kan deklarera en variabel av typen struct man var som helst i hela programmet.
Observera: Häckning av strukturen i sig är aldrig tillåten.Låt oss se ett exempel på hur häckning av struktur i sig inte är tillåtet.
struct teacher
(
char name(20);
char address(100);
int age();
struct teacher principal; // totally invalid way to create nested structure.
)
Exempel på kapslade strukturer i C.
Nedan är de olika exemplen på kapslad struktur i C:
Exempel 1 - Initiering av kapslade strukturer:
Initialisering av kapslade strukturer är möjlig vid tidpunkten för deklarationen.
Koda:
struct student
(
struct person info;
int rollno;
float marks(10);
)
struct student student_1 = (
("Anji", 26, 1995),
103,
92
);
Exempel
Koda:
#include
struct person
(
char name(20);
int age;
char dob(10);
);
struct student
(
struct person info;
int roll_no;
float marks;
);
int main ()
(
struct student p1;
printf("Details of student: \n\n");
printf("Enter name: ");
scanf("%s", p1.info.name);
printf("Enter age: ");
scanf("%d", &p1.info.age);
printf("Enter dob: ");
scanf ("%s", p1.info.dob);
printf("Enter roll no: ");
scanf("%d", &p1.roll_no);
printf("Enter marks: ");
scanf ("%f", &p1.marks);
printf("\n…………………..\n\n");
printf("Name: %s\n", p1.info.name);
printf("Age: %d\n", p1.info.age);
printf("DOB: %s\n", p1.info.dob);
printf("Roll no: %d\n", p1.roll_no);
printf("Marks: %.2f\n", p1.marks);
return 0;
)
Produktion:
Exempel 2 - Tillgång till medlemmar i kapslad struktur med hjälp av Pekare:
Koda:
#include
#include
struct student_college_info
(
int college_id;
char college_name(50);
);
struct student_info
(
int id;
char name(20);
float percentage;
struct student_college_info clg_data;
) stu_data, *stu_data_ptr;
int main()
(
struct student_info stu_data = (2, "Anu", 92.5, 81145,
"SRM University");
stu_data_ptr = &stu_data;
printf(" Id is: %d \n", stu_data_ptr->id);
printf(" Name is: %s \n", stu_data_ptr->name);
printf(" Percentage is: %f \n\n",
stu_data_ptr->percentage);
printf(" College Id is: %d \n",
stu_data_ptr->clg_data.college_id);
printf(" College Name is: %s \n",
stu_data_ptr->clg_data.college_name);
return 0;
)
Produktion:
Exempel 3 - Att överföra strukturmedlem som argument för att fungera:
Koda:
struct teacher
(
char name (20);
int id;
int marks;
);
void print_struct (char name (), int id, int marks);
int main ()
(
struct teacher tea = ("nidhi", 5, 52);
print_struct (tea.name, tea.id, tea.marks);
return 0;
)
void print_struct (char name (), int id, int marks)
(
printf ("Name: %s\n", name);
printf ("id: %d\n", id);
printf ("Marks: %d\n", marks);
printf("\n");
)
Produktion:
Exempel 4 - Struktur inuti strukturen med en normal variabel.
Koda:
#include
#include
struct student_college_detail
(
nt college_id;
char college_name(50);
);
struct student_detail
(
int id;
char name(20);
float percentage;
struct student_college_detail clg_data;
) stu_data;
int main()
(
struct student_detail stu_data = (8, "Moam", 50.5, 562345,
"CSS University");
printf(" Id is: %d \n", stu_data.id);
printf(" Name is: %s \n", stu_data.name);
printf(" Percentage is: %f \n\n", stu_data.percentage);
nbsp;
printf(" College Id is: %d \n",
stu_data.clg_data.college_id);
printf(" College Name is: %s \n",
stu_data.clg_data.college_name);
return 0;
)
Produktion:
Exempel
Koda:
#include
#include
struct student
(
int id1;
int id2;
char e;
char f;
float percentage;
);
int main ()
(
int i;
struct student recrd1 = (3, 4, 'C', 'B', 80.5);
printf ("size of structure in bytes: %d\n",
sizeof(recrd1));
printf ("\nAddress of id1 = %u", &recrd1.id1);
printf("\nAddress of id2 = %u", &recrd1.id2 );
printf("\nAddress of a = %u", &recrd1.e );
printf("\nAddress of b = %u", &recrd1.f );
printf("\nAddress of percentage = %u”, &recrd1.percentage);
return 0;
)
Produktion:
Slutsats
Strukturer i C är ett mycket intressant sätt att klustera och gruppera alla användardefinierade medlemsvariabler och funktioner i en enhet. Men ändå har det vissa begränsningar som att det inte tillåter strukturvariabler och hela strukturen att innehålla de inbyggda datatyperna och ingen användning av operatörer. Därför i dessa framtida kanske dessa funktioner kan tas om hand.
Rekommenderade artiklar
Detta är en guide till den kapslade strukturen i C. Här diskuterar vi arbetet i kapslade strukturen i C tillsammans med olika exempel och kodimplementering. Du kan också titta på följande artikel för att lära dig mer -
- Topp 11 funktioner i C ++
- Exempel på mönster i C-programmering
- Algoritm för C-programmering Matrix Multiplication
- Betydelsen av C # Generics