C/C++學習筆記——C提高：結構體

結構體基礎知識

結構體類型的定義

struct Person{
	char name[64];
	int age;
};

typedef struct _PERSON{
	char name[64];
	int age;
}Person;

注意：定義結構體類型時不要直接給成員賦值，結構體只是一個類型，編譯器還沒有爲其分配空間，只有根據其類型定義變量時，才分配空間，有空間後才能賦值。

結構體變量的定義

struct Person{
	char name[64];
	int age;
}p1; //定義類型同時定義變量


struct{
	char name[64];
	int age;
}p2; //定義類型同時定義變量


struct Person p3; //通過類型直接定義

結構體變量的初始化

struct Person{
	char name[64];
	int age;
}p1 = {"john",10}; //定義類型同時初始化變量

struct{
	char name[64];
	int age;
}p2 = {"Obama",30}; //定義類型同時初始化變量

struct Person p3 = {"Edward",33}; //通過類型直接定義

結構體成員的使用

struct Person{
	char name[64];
	int age;
};
void test(){
	//在棧上分配空間
	struct Person p1;
	strcpy(p1.name, "John");
	p1.age = 30;
	//如果是普通變量，通過點運算符操作結構體成員
	printf("Name:%s Age:%d\n", p1.name, p1.age);

	//在堆上分配空間
	struct Person* p2 = (struct Person*)malloc(sizeof(struct Person));
	strcpy(p2->name, "Obama");
	p2->age = 33;
	//如果是指針變量，通過->操作結構體成員
	printf("Name:%s Age:%d\n", p2->name, p2->age);
}

結構體賦值

賦值基本概念

相同的兩個結構體變量可以相互賦值，把一個結構體變量的值拷貝給另一個結構體，這兩個變量還是兩個獨立的變量。

struct Person{
	char name[64];
	int age;
};

void test(){
	//在棧上分配空間
	struct Person p1 = { "John" , 30};
	struct Person p2 = { "Obama", 33 };
	printf("Name:%s Age:%d\n", p1.name, p1.age);
	printf("Name:%s Age:%d\n", p2.name, p2.age);
	//將p2的值賦值給p1
	p1 = p2;
	printf("Name:%s Age:%d\n", p1.name, p1.age);
	printf("Name:%s Age:%d\n", p2.name, p2.age);
}

深拷貝和淺拷貝

//一個老師有N個學生
typedef struct _TEACHER{
	char* name;
}Teacher;


void test(){
	
	Teacher t1;
	t1.name = malloc(64);
	strcpy(t1.name , "John");

	Teacher t2;
	t2 = t1;

	//對手動開闢的內存，需要手動拷貝
	t2.name = malloc(64);
	strcpy(t2.name, t1.name);

	if (t1.name != NULL){
		free(t1.name);
		t1.name = NULL;
	}
	if (t2.name != NULL){
		free(t2.name);
		t1.name = NULL;
	}
}

結構體數組

struct Person{
	char name[64];
	int age;
};

void test(){
	//在棧上分配空間
	struct Person p1[3] = {
		{ "John", 30 },
		{ "Obama", 33 },
		{ "Edward", 25}
	};

	struct Person p2[3] = { "John", 30, "Obama", 33, "Edward", 25 };
	for (int i = 0; i < 3;i ++){
		printf("Name:%s Age:%d\n",p1[i].name,p1[i].age);
	}
	printf("-----------------\n");
	for (int i = 0; i < 3; i++){
		printf("Name:%s Age:%d\n", p2[i].name, p2[i].age);
	}
	printf("-----------------\n");
	//在堆上分配結構體數組
	struct Person* p3 = (struct Person*)malloc(sizeof(struct Person) * 3);
	for (int i = 0; i < 3;i++){
		sprintf(p3[i].name, "Name_%d", i + 1);
		p3[i].age = 20 + i;
	}
	for (int i = 0; i < 3; i++){
		printf("Name:%s Age:%d\n", p3[i].name, p3[i].age);
	}
}

結構體嵌套指針

結構體嵌套一級指針

struct Person{
	char* name;
	int age;
};

void allocate_memory(struct Person** person){
	if (person == NULL){
		return;
	}
	struct Person* temp = (struct Person*)malloc(sizeof(struct Person));
	if (temp == NULL){
		return;
	}
	//給name指針分配內存
	temp->name = (char*)malloc(sizeof(char)* 64);
	strcpy(temp->name, "John");
	temp->age = 100;

	*person = temp;
}

void print_person(struct Person* person){
	printf("Name:%s Age:%d\n",person->name,person->age);
}

void free_memory(struct Person** person){
	if (person == NULL){
		return;
	}
	struct Person* temp = *person;
	if (temp->name != NULL){
		free(temp->name);
		temp->name = NULL;
	}

	free(temp);
}

void test(){
	
	struct Person* p = NULL;
	allocate_memory(&p);
	print_person(p);
	free_memory(&p);
}

結構體嵌套二級指針

//一個老師有N個學生
typedef struct _TEACHER{
	char name[64];
	char** students;
}Teacher;

void create_teacher(Teacher** teacher,int n,int m){

	if (teacher == NULL){
		return;
	}

	//創建老師數組
	Teacher* teachers = (Teacher*)malloc(sizeof(Teacher)* n);
	if (teachers == NULL){
		return;
	}

	//給每一個老師分配學生
	int num = 0;
	for (int i = 0; i < n; i ++){
		sprintf(teachers[i].name, "老師_%d", i + 1);
		teachers[i].students = (char**)malloc(sizeof(char*) * m);
		for (int j = 0; j < m;j++){
			teachers[i].students[j] = malloc(64);
			sprintf(teachers[i].students[j], "學生_%d", num + 1);
			num++;
		}
	}

	*teacher = teachers;	
}

void print_teacher(Teacher* teacher,int n,int m){
	for (int i = 0; i < n; i ++){
		printf("%s:\n", teacher[i].name);
		for (int j = 0; j < m;j++){
			printf("  %s",teacher[i].students[j]);
		}
		printf("\n");
	}
}

void free_memory(Teacher** teacher,int n,int m){
	if (teacher == NULL){
		return;
	}

	Teacher* temp = *teacher;

	for (int i = 0; i < n; i ++){
		
		for (int j = 0; j < m;j ++){
			free(temp[i].students[j]);
			temp[i].students[j] = NULL;
		}

		free(temp[i].students);
		temp[i].students = NULL;
	}

	free(temp);

}

void test(){
	
	Teacher* p = NULL;
	create_teacher(&p,2,3);
	print_teacher(p, 2, 3);
	free_memory(&p,2,3);
}

結構體成員偏移量

//一旦結構體定義下來，則結構體中的成員內存佈局就定下了
typedef struct Teacher
{
	char a;  
	int b;      
	int c;        

} Teacher;

void test(){
	
	Teacher  t1;
	Teacher*p = NULL;
	p = &t1;

	int offsize1 = (int)&(p->b) - (int)p;  //age 相對於結構體 Teacher的偏移量
	int offsize2 = (int)&(((Teacher *)0)->b);//絕對0地址 age的偏移量
	int offsize3 = offsetof(Teacher, b);

	printf("offsize1:%d \n", offsize1);
	printf("offsize2:%d \n", offsize2);
	printf("offsize3:%d \n", offsize3);
}

結構體字節對齊

在用sizeof運算符求算某結構體所佔空間時，並不是簡單地將結構體中所有元素各自佔的空間相加，這裏涉及到內存字節對齊的問題。
從理論上講，對於任何變量的訪問都可以從任何地址開始訪問，但是事實上不是如此，實際上訪問特定類型的變量只能在特定的地址訪問，這就需要各個變量在空間上按一定的規則排列，而不是簡單地順序排列，這就是內存對齊。

內存對齊

內存對齊原因

我們知道內存的最小單元是一個字節，當cpu從內存中讀取數據的時候，是一個一個字節讀取，所以內存對我們應該是入下圖這樣：

但是實際上cpu將內存當成多個塊，每次從內存中讀取一個塊，這個塊的大小可能是2、4、8、16等，
那麼下面，我們來分析下非內存對齊和內存對齊的優缺點在哪？
內存對齊是操作系統爲了提高訪問內存的策略。操作系統在訪問內存的時候，每次讀取一定長度(這個長度是操作系統默認的對齊數，或者默認對齊數的整數倍)。如果沒有對齊，爲了訪問一個變量可能產生二次訪問。

至此大家應該能夠簡單明白，爲什麼要簡單內存對齊？

提高存取數據的速度。比如有的平臺每次都是從偶地址處讀取數據，對於一個int型的變量，若從偶地址單元處存放，則只需一個讀取週期即可讀取該變量；但是若從奇地址單元處存放，則需要2個讀取週期讀取該變量。
某些平臺只能在特定的地址處訪問特定類型的數據，否則拋出硬件異常給操作系統。

如何內存對齊

對於標準數據類型，它的地址只要是它的長度的整數倍。
對於非標準數據類型，比如結構體，要遵循一下對齊原則：

數組成員對齊規則。第一個數組成員應該放在offset爲0的地方，以後每個數組成員應該放在offset爲min（當前成員的大小，#pargama pack(n)）整數倍的地方開始（比如int在32位機器爲４字節，#pargama pack(2)，那麼從2的倍數地方開始存儲）。
結構體總的大小，也就是sizeof的結果，必須是min（結構體內部最大成員，#pargama pack(n)）的整數倍，不足要補齊。
結構體做爲成員的對齊規則。如果一個結構體B裏嵌套另一個結構體A,還是以最大成員類型的大小對齊，但是結構體A的起點爲A內部最大成員的整數倍的地方。（struct B裏存有struct A，A裏有char，int，double等成員，那A應該從8的整數倍開始存儲。），結構體A中的成員的對齊規則仍滿足原則1、原則2。

手動設置對齊模數:

#pragma pack(show)
顯示當前packing alignment的字節數，以warning message的形式被顯示。
#pragma pack(push)
將當前指定的packing alignment數組進行壓棧操作，這裏的棧是the internal compiler stack,同事設置當前的packing alignment爲n；如果n沒有指定，則將當前的packing alignment數組壓棧。
#pragma pack(pop)
從internal compiler stack中刪除最頂端的reaord; 如果沒有指定n,則當前棧頂record即爲新的packing alignement數值；如果指定了n，則n成爲新的packing alignment值
#pragma pack(n)
指定packing的數值，以字節爲單位，缺省數值是8，合法的數值分別是1,2,4,8,16。

內存對齊案例

#pragma pack(4)

typedef struct _STUDENT{
	int a;
	char b;
	double c;
	float d;
}Student;

typedef struct _STUDENT2{
	char a;
	Student b; 
	double c;
}Student2;

void test01(){

	//Student
	//a從偏移量0位置開始存儲
	//b從4位置開始存儲
	//c從8位置開始存儲
	//d從12位置開存儲
	//所以Student內部對齊之後的大小爲20 ，整體對齊，整體爲最大類型的整數倍 也就是8的整數倍 爲24

	printf("sizeof Student:%d\n",sizeof(Student));

	//Student2 
	//a從偏移量爲0位置開始 8
	//b從偏移量爲Student內部最大成員整數倍開始，也就是8開始 24
	//c從8的整數倍地方開始,也就是32開始
	//所以結構體Sutdnet2內部對齊之後的大小爲：40 ， 由於結構體中最大成員爲8，必須爲8的整數倍 所以大小爲40
	printf("sizeof Student2:%d\n", sizeof(Student2));
}

C/C++學習筆記——C提高：結構體

結構體基礎知識

結構體類型的定義

結構體變量的定義

結構體變量的初始化

結構體成員的使用

結構體賦值

賦值基本概念

深拷貝和淺拷貝

結構體數組

結構體嵌套指針

結構體嵌套一級指針

結構體嵌套二級指針

結構體成員偏移量

結構體字節對齊

內存對齊

內存對齊原因

如何內存對齊

內存對齊案例

C/C++學習筆記——C基礎：數據類型

C/C++學習筆記——C基礎：複合類型(自定義類型)

C/C++學習筆記——C提高：C語言概述

C/C++學習筆記——C提高：預處理

C/C++學習筆記——C提高：結構體

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

C/C++學習筆記——C提高： 結構體

結構體基礎知識

結構體類型的定義

結構體變量的定義

結構體變量的初始化

結構體成員的使用

結構體賦值

賦值基本概念

深拷貝和淺拷貝

結構體數組

結構體嵌套指針

結構體嵌套一級指針

結構體嵌套二級指針

結構體成員偏移量

結構體字節對齊

內存對齊

內存對齊原因

如何內存對齊

內存對齊案例

C/C++學習筆記——C提高：結構體