Структуры ў праграмаванні на C


ўвядзенне

Калі мы пішам праграмы для задавальнення патрабаванняў рэальнага свету, зменныя і іх тыпы дадзеных не абмяжоўваюцца адным тыпам зменных. Мы будзем мець розныя патрабаванні, каб розныя тыпы зменных былі аб'яднаны і выкліканы з выкарыстаннем аднаго імя. Напрыклад вучні ў класе. Калі мы кажам, што студэнт, мы маем шмат інфармацыі, звязанай з ім, якую трэба захоўваць і атрымліваць да яго доступ, напрыклад, яго пасведчанне асобы, імя, узрост, клас і г.д. Тут мы можам захоўваць усю гэтую інфармацыю ў асобных зменных. Гэта будзе добра працаваць, калі ёсць толькі адзін студэнт. Кожная яго інфармацыя можа захоўвацца ў адпаведных зменных з правільнымі тыпамі дадзеных.

INT intStdId;
калясьніца chrStdName [15];
INT intAge;
калясьніца chrClassId [10];

Але ў класе ці каледжы колькасць навучэнцаў не абмяжоўваецца адным. Шмат будзе студэнтаў. Як мы ўжо бачылі, калі ў нас ёсць некалькі аднолькавых дадзеных, мы звычайна выкарыстоўваем масівы. Такім чынам, нам можа спатрэбіцца стварыць масівы для кожнай з пераменных вышэй. Цяпер ён можа захоўваць дадзеныя для любой колькасці студэнтаў у класе / каледжы.

INT intStdId [100];
калясьніца chrStdName [100] [15];
INT intAge [100];
калясьніца chrClassId [100] [10];

На прыведзенай вышэй ілюстрацыі мы захоўваем 100 інфармацый для студэнтаў. Што рабіць, калі мы атрымаем больш новых студэнтаў? Гэтага масіва будзе недастаткова. Мы павінны змяніць усе зменныя масіва, якія выкарыстоўваюцца для захоўвання інфармацыі пра студэнтаў, каб захаваць большую колькасць студэнтаў. Акрамя таго, мы павінны змяніць код усюды, дзе мы выкарыстоўваем гэтыя масівы, для завес (для павелічэння індэкса), умоў і г.д.

Акрамя вышэйзгаданага пытання, ёсць яшчэ адно пытанне адлюстравання дэталяў студэнтаў. Усе гэтыя пераменныя масіва не залежаць адна ад адной, нават нягледзячы на ​​тое, што яны выкарыстоўваюцца для захоўвання звестак студэнта. Мы ведаем, што яны выкарыстоўваюцца для падрабязнасцей студэнтаў, бо мы іх кадзіруем. Акрамя таго, мы маглі б прытрымлівацца правіла, што першы элемент усіх зменных масіва ўтрымлівае падрабязнасці аднаго студэнта, наступныя наступныя элементы захоўваюць звесткі пра наступных наступных студэнтаў. Але якая гарантыя таго, што яны заўсёды захоўваюцца аднолькава? У гэтых тыпах не звязаных масіваў заўсёды існуе вялікая магчымасць змешвання дадзеных паміж яго элементамі. Такім чынам, заўсёды будзе страх мець няправільныя звесткі пра вучня.

Усе гэтыя праблемы прымушаюць нас думаць пра тое, каб выкарыстоўваць іншы спосаб захоўвання дадзеных і доступу да іх, не прапускаючы дадзеныя і не ствараючы няправільных дадзеных. Тут мы заўсёды аддалі перавагу б, каб асобныя дадзеныя студэнта захоўваліся ў адной зменнай, а не ў некалькіх зменных. Калі ён захоўваецца ў адной зменнай, у нас не будзе перакрыжаванага адлюстравання дэталяў студэнта. Але калі мы кажам адну зменную, захоўванне ўсіх ідэнтыфікатараў, імёнаў, узросту, класа і г.д. у такой зменнай, як доўгі радок, не дапаможа. Выманне кожнага значэння з радка было б складанай задачай. Такім чынам, нам трэба мець зменныя такім чынам, каб,

  • Кожны элемент, звязаны са студэнтам, павінен быць дакладна вызначаны
  • Не павінна быць перакрыжаванага адлюстравання альбо няправільнай інтэрпрэтацыі дадзеных.
  • Кожны элемент студэнта павінен мець розныя зменныя з адпаведным тыпам дадзеных, але ўсё ж мы павінны мець магчымасць ідэнтыфікаваць іх, выкарыстоўваючы адно імя.

Усё гэта магчыма пры выкарыстанні спецыяльнага тыпу дадзеных у C, які называецца структурамі. Гэта вытворныя тыпы дадзеных у C, які змяшчае зменныя прымітыўныя тыпы дадзеных і вытворныя тыпы дадзеных пад адным імем, якое з'яўляецца іншай зменнай.

У нашым прыведзеным вышэй прыкладзе мы маем пасведчанне студэнта, імя студэнта, узрост і ідэнтыфікатары класа, якія звязаны са студэнтам, і мы хацелі б назваць іх студэнтамі. Такім чынам, мы ствараем структуру студэнта, якая будзе мець свае элементы як ідэнтыфікатар, імя, узрост і клас з прымітыўнымі / непрымітыўнымі тыпамі дадзеных.

Калі ў нас некалькі студэнтаў, мы можам стварыць масіў структуры студэнт, які робіць любыя копіі студэнтаў. Такім чынам, няма страху перакрыжаванага адлюстравання дадзеных. Кожны элемент масіва структуры будзе ўтрымліваць свае ўласныя элементы, якія нельга змешваць з іншымі элементамі масіва структуры.

Ніжэй прыведзена схема пра структуру, якая ачысціць гэтыя паняцці.

Такім чынам, калі мы кажам студэнт [0], мы будзем мець усю інфармацыю для студэнта, якая захоўваецца ў месцы 0 і гэтак далей. У нас можа быць нават іншая структура ў рамках адной структуры.

Гэтыя выдатныя канцэпцыі структуры робяць C больш магутным для вырашэння ўсіх сцэнарыяў рэальнага жыцця.

Ёсць шмат сітуацый, калі мы выкарыстоўваем структуры: адрас, звесткі пра супрацоўнікаў, дадзеныя пра аўтара, інфармацыю пра кнігі і г.д. Давайце зараз паглядзім, як ствараць структуры.

Дэкларацыя і тып

Як мы абмяркоўвалі вышэй, у любой структуры будзе адзін ці некалькі прымітыўных ці непрымітыўных тыпаў дадзеных. Значыць, гэта будзе форма абгорткі.

Агульны сінтаксіс стварэння структуры прыведзены ніжэй:

struct struct_name{
	datatype variable1;
	datatype variable2;
	….
	datatype variableN;
};

Тут ключавое слова struct выкарыстоўваецца, каб паказаць, што гэта зменны тып структуры, за якім ідзе назва структуры. Унутры яго будуць зменены элементы з адпаведнымі тыпамі дадзеных.

Структуру студэнта вышэй можна аб'явіць, як паказана ніжэй:

struct student{
    int intStdId;
    char chrStdName[15];
    int intAge;
    char chrClassId[10];
};

Тут структура студэнта мае 4 элементы - ідэнтыфікатар, імя, узрост і ідэнтыфікатар класа са сваім тыпам дадзеных.

Абвяшчэнне структуры стварае каркас структуры. Ён не ўяўляе рэальнай зменнай. Ён стварае толькі каркас для стварэння зменнай. Гэтая структура студэнтаў не будзе дзейнічаць у якасці зменнай. Але гэта стварае палажэнне аб аб'яўленні любой іншай зменнай як студэнцкай. Гэта падобна на стварэнне вызначанага карыстальнікам тыпу дадзеных і выкарыстанне гэтага тыпу дадзеных для аб'яўлення зменных.

Гэта значыць, калі нам трэба прысвоіць якія-небудзь звесткі студэнта вышэйпаказанай структуры, спачатку нам трэба стварыць зменную структуры, тып дадзеных якой з'яўляецца студэнтам, г.зн.

структура студэнт struct_std1, struct_std2;

Цяпер struct_std1 і struct_std2 называюцца экземплярам студэнта структуры. Дапусцім, нам трэба стварыць набор студэнтаў з аднолькавай структурай. Гэта можна зрабіць гэтак жа, як мы аб'яўляем масіў. Тут мы выкарыстоўваем тып структуры замест любых прымітыўных тыпаў дадзеных.

структура студэнт struct_StdArr [10]; // стварае масіў структуры з 10 элементаў

Над адным - простая канструкцыя. Мы можам мець складаную структуру - структуру ў структуры. Гэта называецца ўкладзенымі структурамі. Разгледзім адну і тую ж структуру студэнта з аднолькавымі элементамі разам з іх адрасам. Тут Адрас не можа быць адзінай зменнай. Ён будзе мець дзверы #, вуліцу #, горад, штат і пін-код. Такім чынам, яго можна разглядаць як іншую структуру. Паколькі гэта звязана са студэнтам, структуру адрасоў трэба дэклараваць у структуры студэнта.

struct student{
	int intStdId;
	char chrStdName[15];
	int intAge;
	char chrClassId[10];
	struct address{
		int intDoorNum;
		char chrstreet[15];
		char chrCity[15];
		char chrState[15];
		int intPincode;
	};
};

Цяпер асобнік студэнцкай структуры можна стварыць гэтак жа, як і раней. Гэтая новая структура студэнта вызначае новае вызначэнне для тыпу структуры студэнта са структурай адрасоў у ёй, г.зн.

структура студэнт struct_std1, struct_std2;

Мы нават можам стварыць асобнік структуры, аб'яўляючы іх самі.

struct student{
	int intStdId;
	char chrStdName[15];
	int intAge;
	char chrClassId[10];
}struct_std1, struct_std2; // 2 instances are created

 
struct student{
	int intStdId;
	char chrStdName[15];
	int intAge;
	char chrClassId[10];
	struct address{
		int intDoorNum;
		char chrstreet[15];
		char chrCity[15];
		char chrState[15];
		int intPincode;
	}struct_addr; //instance of address
}struct_std; //instance of student

Мы нават можам стварыць структуру адрасоў асобна па-за структурай студэнта, а потым можам стварыць асобнік адраса, створаны ў студэнце. Гэта таксама працуе гэтак жа, як і вышэй.
struct address{
	int intDoorNum;
	char chrstreet[15];
	char chrCity[15];
	char chrState[15];
	int intPincode;
};
struct student{
	int intStdId;
	char chrStdName[15];
	int intAge;
	char chrClassId[10];
	struct address struct_addr; // instance of address structure is created
}struct_std1; // one method of creating instance
struct student struct_std2; //another method of creating instance

Доступ да элементаў структуры

Мы аб'явілі структуру і стварылі яе зменныя / асобнікі. Цяпер пытанне ў тым, як атрымаць доступ да элементаў у структуры. Паколькі ён упакаваны пад адзіным імем і да яго павінен мець унікальны доступ кожны студэнт, доступ да яго элемента таксама павінен быць адназначным. Мы не маем непасрэднага доступу да элементаў, як да любых іншых зменных.

Патрабаванне структуры прымушае яго дадаваць імя зменнай структуры перад яго зменнымі элементамі. Гэта дазваляе адназначна атрымаць доступ да сваіх элементаў і спыняе яго ад любога перакрыжаванага адлюстравання.

У нашым прыкладзе структуры студэнта мы можам атрымаць доступ да яе элементаў, як паказана ніжэй:

структура студэнт struct_std1, struct_std2;

struct_std1.intStdId = 100;
strcpy (struct_std1.chrStdName,"Ружа");
struct_std1.intAge = 20;
strcpy (struct_std1.chrClassId,“CLS_001”);

struct_std2.intStdId = 200;
strcpy (struct_std1.chrStdName,"Мэцью");
struct_std2.intAge = 22;
strcpy (struct_std2.chrClassId, “CLS_232”);

Тут мы маем дзве структурныя зменныя struct_std1 і struct_std2. Іх адпаведным элементам прысвойваюцца значэнні шляхам доступу да іх, дадаючы імёны адпаведных зменных структур - struct_std1.intStdId, struct_std1.chrStdName, struct_std1.intAge, struct_std1.chrClassId і г.д.

Значэнні таксама могуць быць прызначаныя непасрэдна, як гэта робіцца з любымі іншымі нармальнымі зменнымі. Тут радкавыя значэнні прызначаюцца з дапамогай функцыі strcpy, бо элемент структуры з'яўляецца радкавай зменнай і не дазваляе нам непасрэдна прысвойваць значэнне. Больш падрабязна пра strcpy будзе разгледжана ў апошніх тэмах.

Калі нам трэба надрукаваць яго значэнні, мы можам выкарыстоўваць яго такім жа чынам.

#include <stdio.h> 
#include <string.h> 

void main() {
	struct student{ // if this structure needs to be accessed by other functions too, then place this structure definition outside the main function
		int intStdId;
		char chrStdName[15];
		int intAge;
		char chrClassId[10];
		struct address{
			int intDoorNum;
			char chrstreet[15];
			char chrCity[15];
			char chrState[15];
			int intPincode;
		};
	};
	struct student struct_std1, struct_std2;

	struct_std1.intStdId = 100;
	strcpy(struct_std1.chrStdName, "Rose");
	struct_std1.intAge = 20;
	strcpy(struct_std1.chrClassId, "CLS_001");
	struct_std1.intDoorNum = 121;
	strcpy(struct_std1.chrState, "Bangalore");

	struct_std1.intStdId = 200;
	strcpy(struct_std1.chrStdName, "Mathew");
	struct_std1.intAge = 22;
	strcpy(struct_std1.chrClassId, "CLS_232");
	
	printf("\nValue of student Id in struct_std1 is : %d", struct_std1.intStdId);
	printf("\nValue of student Name in struct_std1 is : %s", struct_std1.chrStdName);
	printf("\nValue of student age in struct_std1 is : %d", struct_std1.intAge);
	printf("\nValue of student class  in struct_std1 is : %s", struct_std1.chrClassId);
	printf("\nValue of Door Number in struct_std1 is : %d", struct_std1.intDoorNum);

	printf("\nValue of student Id in struct_std2 is : %d", struct_std2.intStdId);
	printf("\nValue of student Id in struct_std2 is : %s", struct_std2.chrStdName);
	printf("\nValue of student Id in struct_std2 is : %d", struct_std2.intAge);
	printf("\nValue of student Id in struct_std2 is : %s", struct_std2.chrClassId);
}

Ніжэй прыведзены вынікі вышэйзгаданай праграмы

Тут мы можам заўважыць, што да элемента структуры адраса звяртаюцца так, нібы яны з'яўляюцца прамымі элементамі студэнта. Гэта таму, што структура адрасоў знаходзіцца ў структуры студэнта.

Гэта адзін з прыкладаў доступу да структуры ў структуры. Ёсць некалькі спосабаў стварыць структуры і атрымаць да іх доступ.

Некаторыя іншыя метады ініцыялізацыі і доступу да элементаў структуры паказаны ніжэй:

struct student{
	int intStdId;
	char chrStdName[15];
	int intAge;
	char chrClassId[10];
}struct_std1 = { 100, "Rose", 20, "CLS_001" }; // creating an instance and initializing its elements
printf("\nValue of student Id in struct_std1 is : %d", struct_std1.intStdId);
printf("\nValue of student Name in struct_std1 is : %s", struct_std1.chrStdName);
printf("\nValue of student age in struct_std1 is : %d", struct_std1.intAge);
…

struct student{
	int intStdId;
	char chrStdName[15];
	int intAge;
	char chrClassId[10];
}struct_std1 // creating an instance 
struct student struct_std1 = { 100, "Rose", 20, "CLS_001" }; // initializing its elements
printf("\nValue of student Id in struct_std1 is : %d", struct_std1.intStdId);
printf("\nValue of student Name in struct_std1 is : %s", struct_std1.chrStdName);
printf("\nValue of student age in struct_std1 is : %d", struct_std1.intAge);
…

struct student{
	int intStdId;
	char chrStdName[15];
	int intAge;
	char chrClassId[10];
	struct address{
		int intDoorNum;
		char chrstreet[15];
		char chrCity[15];
		char chrState[15];
		int intPincode;
	}struct_addr; //instance of address
}struct_std = { 100, "Rose", 20, "CLS_001", { 121, "MS Road", "Bangalore", "KA", 560034 } };
printf("\nValue of student Id in struct_std is : %d", struct_std.intStdId);
printf("\nValue of student Name in struct_std is : %s", struct_std.chrStdName);
printf("\nValue of Door Num in struct_std is : %d", struct_std. struct_addr. intDoorNum);
printf("\nValue of State in struct_std is : %s", struct_std. struct_addr. chrState);

У гэтым прыкладзе дадаецца экземпляр адраса, таму што мы стварылі яго. Паколькі створаны асобнік унутранай структуры, мы не можам атрымаць непасрэдны доступ да іх элементаў. Нам трэба атрымаць доступ да элементаў унутранай структуры праз экземпляр унутранай структуры, як паказана ў прыведзеным вышэй прыкладзе - struct_std. struct_addr. intDoorNum.
struct address{
	int intDoorNum;
	char chrstreet[15];
	char chrCity[15];
	char chrState[15];
	int intPincode;
};
struct student{
	int intStdId;
	char chrStdName[15];
	int intAge;
	char chrClassId[10];
	struct address struct_addr; // instance of address structure is created
}struct_std1; // one method of creating instance
struct student struct_std2; //another method of creating instance
printf("\nValue of student Id in struct_std1 is : %d", struct_std1.intStdId);
printf("\nValue of student Name in struct_std1 is : %s", struct_std1.chrStdName);
printf("\nValue of student age in struct_std1 is : %d", struct_std1.intAge);
printf("\nValue of Door Num in struct_std is : %d", struct_std1. struct_addr. intDoorNum);

printf("\nValue of student Id in struct_std2 is : %d", struct_std2.intStdId);
printf("\nValue of student Name in struct_std2is : %s", struct_std2.chrStdName);
printf("\nValue of student age in struct_std2 is : %d", struct_std2.intAge);
printf("\nValue of Door Num in struct_std is : %d", struct_std2. struct_addr. intDoorNum);

Тут абодва экземпляры студэнцкага доступу да экземпляра ўнутранай структуры з аднолькавым імем. яны не перакрываюцца тут як struct_addr, хаця экземпляр структуры ён прадстаўляе зменную / элемент студэнцкай структуры.

Вышэй прыведзены розныя метады стварэння асобнікаў структуры, іх ініцыялізацыі і доступу да іх. Дапусцім, нам трэба стварыць масіў структур. Затым мы ствараем асобнік як масіў у любым з прыведзеных вышэй спосабаў.

#include <stdio.h> 
#include <string.h> 

void main() {
 
	struct student{
		int intStdId;
		char chrStdName[15];
		int intAge;
		char chrClassId[10];
		struct address{
			int intDoorNum;
			char chrstreet[15];
			char chrCity[15];
			char chrState[15];
			int intPincode;
		}struct_addr; //instance of address
	};

	struct student struct_std[10];

	//initializing different elements of array of structures
	struct_std[0].intStdId = 100;
	strcpy(struct_std[0].chrStdName, "Rose");
	struct_std[1].struct_addr.intDoorNum = 232;
	strcpy(struct_std[2].struct_addr.chrState,"KA");

	printf("\nstruct_std[0] values");
	printf("\nValue of student Id in struct_std is : %d", struct_std[0].intStdId);
	printf("\nValue of student Name in struct_std is : %s", struct_std[0].chrStdName);
	printf("\n\nstruct_std[1] values");
	printf("\nValue of Door Num in struct_std is : %d", struct_std[1].struct_addr.intDoorNum);
	printf("\n\nstruct_std[2] values");
	printf("\nValue of State in struct_std is : %s", struct_std[2].struct_addr.chrState);
}

У нас могуць быць указальнікі на асобнік структуры. Мы ствараем зменную структуру як паказальнікі, тады мы павінны атрымаць доступ да членаў структуры, выкарыстоўваючы '→' замест '.'.
#include <stdio.h> 
#include <string.h> 

void main() {
 
	struct student{
		int intStdId;
		char chrStdName[15];
		int intAge;
		char chrClassId[10];
	};
	struct student std;// creating normal structure variable
	struct student *struct_std1; // creating a structure pointer

		// Initializing the structure elements 
	std.intStdId = 100;
	strcpy(std.chrStdName, "Rose");
	std.intAge = 20;
	strcpy(std.chrClassId, "CLS_001");

	struct_std1 = &std; // Make structure pointer to point to structure std

	//Access the structure pointer elements
	printf("\nValue of student Id in struct_std is : %d", struct_std1->intStdId);
	printf("\nValue of student Name in struct_std is : %s", struct_std1->chrStdName);
	printf("\nValue of student age in struct_std is : %d", struct_std1->intAge);
	printf("\nValue of student Class in struct_std is : %s", struct_std1->chrClassId);
}

Ніжэй прыведзены вынікі вышэйзгаданай праграмы

Масівы канструкцый

Мы ўжо абмяркоўвалі, як справіцца з патрабаваннем аб'яднаць розныя тыпы элементаў у адно імя, выкарыстоўваючы структуру. Гэтая структура, вызначаная да гэтага часу, здольная апрацоўваць дадзеныя для аднаго студэнта. Структура студэнт, хоць і вызначана як ідэнтыфікатар, імя, узрост і клас, яна ўтрымлівае дадзеныя пра аднаго студэнта. Калі мы дадаем іншага студэнта да той самай зменнай структуры, старая інфармацыя перазапісваецца. Такім чынам, мы павінны аб'явіць іншую зменную структуры тыпу student, каб апрацоўваць іншага студэнта. Але што будзе, калі колькасць студэнтаў будзе больш, скажам, 50 ці 100 ці нават больш? Складана стварыць так шмат структурных зменных і апрацоўваць іх у кодзе. Гэта памяншае чытальнасць кода, а таксама павялічвае складанасць кода. Такім чынам, C спалучае асаблівасці структуры з асаблівасцямі масіва. Іншымі словамі, С дазваляе нам ствараць масіў структур. Ён ствараецца гэтак жа, як мы ствараем масіў цэлых лікаў або сімвалаў.

Мы аб'яўляем масіў структуры тыпу, каб стварыць масіў структур, як паказана ніжэй:

struct student{
	int intStdId;
	char chrStdName[15];
	int intAge;
	char chrClassId[10];
};
struct student std[10];// creating an array of structures with 10 structure elements

Вышэй набору кода ствараецца масіў з 10 элементаў. Але элементы масіва - гэта структуры тыпу student. Гэта азначае, што кожны элемент масіва будзе мець 33 байты памяці, прызначаныя для ўтрымання ідэнтыфікатара, імя, узросту і класа кожнага студэнта.

Ніжэй дыяграма паказвае масіў структур з 3 элементамі. Хоць асобныя элементы структуры прадстаўлены ніжэй, рознакаляровыя блокі ўтвараюць адзінкавыя элементы масіва. Паколькі кожны элемент з'яўляецца структурай, памяць, выдзеленая для кожнага элемента, дзеліцца паміж элементамі структуры. Кожны элемент масіва размяшчаецца адзін за адным у памяці.

Мы можам атрымаць доступ да масіву структур, выкарыстоўваючы '.' Такія аператары, як мы, атрымліваюць доступ да любых элементаў структуры. Паколькі гэта масіў, мы павінны ўказаць індэкс масіва, каб прадставіць, які элемент масіва мы маем доступ.

Std [0] .intStdId = 100; // ініцыялізуе член intStdId першага элемента масіва структуры
Std [2] .StdName = "Майк";// ініцыялізуе член StdName трэцяга элемента масіва структуры

Вылучэнне памяці ў структуры

Як і любой іншай зменнай, структуры таксама неабходна выдзяляць памяць для яе захоўвання дадзеных. Але памяць, выдзеленая для любой структуры, не можа быць пастаяннай, як любыя іншыя тыпы дадзеных, такія як int, float, long, char і г. д. Гэта таму, што; Структура можа мець адзін або некалькі элементаў розных тыпаў. Такім чынам, яго памер і памяць змяняюцца ў залежнасці ад элементаў у структуры.

У структуры асобным элементам выдзяляецца памяць у адпаведнасці з іх тыпам дадзеных, і памяць, выдзеленая для структуры, будзе сумай памяці, выдзеленай для асобных элементаў структуры. Напрыклад, разгледзім простую структуру вучняў.

struct student{
        int intStdId;
        char chrStdName[15];
        int intAge;
        char chrClassId[10];
}struct_std;

Тут памер структурнай зменнай struct_std задаецца сумай памеру асобных элементаў - intStdId, chrStdName, intAge і chrClassId. г.зн.

Памер (intStdId) + sizeof (chrStdName) + памер (intAge) + памер (chrClassId)
= 4 + 15+ 4+ 10
= 33 байт.

З гэтага мы можам зразумець, што нягледзячы на ​​тое, што асобныя члены займаюць свае асобныя прасторы ў памяці, калі мы абвяшчаем зменную структуры struct_std, нам патрэбныя 33 байты бесперапыннай памяці. Затым ён дзеліцца для размяшчэння сваіх членаў.

Разгледзім укладзеную структуру, каб вылічыць размеркаванне памяці.

struct student{
	int intStdId;
	char chrStdName[15];
	int intAge;
	char chrClassId[10];
	struct address{
		int intDoorNum;
		char chrstreet[15];
		char chrCity[15];
		char chrState[15];
		int intPincode;
	}struct_addr; //instance of address
} struct_std;

Тут ізноў гэта сума ўсіх яго элементаў. Калі ёсць унутраная структура, для вылічэння яе памеру выкарыстоўваецца той жа метад, які потым дадаецца для вылічэння памеру знешняй канструкцыі. г.зн.

Памер (intStdId) + sizeof (chrStdName) + памер (intAge) + памер (chrClassId) + Памер (адрас) == Памер (intStdId) + sizeof (chrStdName) + памер (intAge) + памер (chrClassId) + sizeof (intDoorNum) + памер (chrstreet) + памер (chrCity) + памер (chrState) + памер з (intPincode)

= 4 + 15+ 4+ 10 + 4 + 15 + 15 + 15 + 4 = 86 байт.

Такім чынам, памер канструкцыі залежыць ад колькасці і памераў яе элементаў.