天天看點
傳回

熬夜整理的萬字C/C++總結（四），值得收藏

1、結構體

1.1 結構體基礎知識

程式員書籍資源，值得收藏！，點選檢視

h這一定是你需要的電子書資源，全！值得收藏！

1.1.1 結構體類型的定義

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

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

複制

注意：定義結構體類型時不要直接給成員指派，結構體隻是一個類型，編譯器還沒有為其配置設定空間，隻有根據其類型定義變量時，才配置設定空間，有空間後才能指派。

1.1.2 結構體變量的定義

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

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

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

複制

1.1.3 結構體變量的初始化

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

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

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

複制

1.1.4 結構體成員的使用

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);
}

複制

1.1.5 結構體指派

1.1.5.1 指派基本概念

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

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);
}

複制

1.1.5.1 深拷貝和淺拷貝

//一個老師有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;
 }
}

複制

1.1.6 結構體數組

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);
 }
}

複制

1.2 結構體嵌套指針

1.2.1 結構體嵌套一級指針

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);
}

複制

1.2.2 結構體嵌套二級指針

//一個老師有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);
}

複制

1.3 結構體成員偏移量 

//一旦結構體定義下來，則結構體中的成員記憶體布局就定下了
#include <stddef.h>
struct Teacher
{
 char a;
 int b;
};

void test01(){

 struct Teacher  t1;
 struct Teacher*p = &t1;


 int offsize1 = (int)&(p->b) - (int)p;  //成員b 相對于結構體 Teacher的偏移量
 int offsize2 = offsetof(struct Teacher, b);

 printf("offsize1:%d \n", offsize1); //列印b屬性對于首位址的偏移量
 printf("offsize2:%d \n", offsize2);
}

複制

1.4 結構體位元組對齊

在用 sizeof 運算符求算某結構體所占空間時，并不是簡單地将結構體中所有元素各自占的空間相加，這裡涉及到記憶體位元組對齊的問題。

從理論上講，對于任何變量的通路都可以從任何位址開始通路，但是事實上不是如此，實際上通路特定類型的變量隻能在特定的位址通路，這就需要各個變量在空間上按一定的規則排列， 而不是簡單地順序排列，這就是記憶體對齊。

1.4.1.1 記憶體對齊原因

我們知道記憶體的最小單元是一個位元組，當 cpu 從記憶體中讀取資料的時候，是一個一個位元組讀取，是以記憶體對我們應該是入下圖這樣：

熬夜整理的萬字C/C++總結（四），值得收藏

但是實際上 cpu 将記憶體當成多個塊，每次從記憶體中讀取一個塊，這個塊的大小可能是2、4、8、16等，

那麼下面，我們來分析下非記憶體對齊和記憶體對齊的優缺點在哪？

記憶體對齊是作業系統為了提高通路記憶體的政策。作業系統在通路記憶體的時候，每次讀取一定長度(這個長度是作業系統預設的對齊數，或者預設對齊數的整數倍)。如果沒有對齊，為了通路一個變量可能産生二次通路。

至此大家應該能夠簡單明白，為什麼要簡單記憶體對齊？
  • 提高存取資料的速度。比如有的平台每次都是從偶位址處讀取資料，對于一個int型的變量，若從偶位址單元處存放，則隻需一個讀取周期即可讀取該變量；但是若從奇位址單元處存放，則需要2個讀取周期讀取該變量。
  • 某些平台隻能在特定的位址處通路特定類型的資料，否則抛出硬體異常給作業系統。

1.4.1.1 如何記憶體對齊

  • 對于标準資料類型，它的位址隻要是它的長度的整數倍。
  • 對于非标準資料類型，比如結構體，要遵循一下對齊原則：
  1. 數組成員對齊規則。第一個數組成員應該放在offset為0的地方，以後每個數組成員應該放在offset為min（目前成員的大小，#pargama pack(n)）整數倍的地方開始（比如int在32位機器為４位元組，#pargama pack(2)，那麼從2的倍數地方開始存儲）。
  2. 結構體總的大小，也就是sizeof的結果，必須是min（結構體内部最大成員，#pargama pack(n)）的整數倍，不足要補齊。
  3. 結構體做為成員的對齊規則。如果一個結構體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。

1.4.2 記憶體對齊案例

#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位置開始 
 //b從偏移量為Student内部最大成員整數倍開始，也就是8開始
 //c從8的整數倍地方開始,也就是32開始
 //是以結構體Sutdnet2内部對齊之後的大小為：40 ， 由于結構體中最大成員為8，必須為8的整數倍 是以大小為40
 printf("sizeof Student2:%d\n", sizeof(Student2));
}

複制

上一篇: Umi&amp;React打包部署到非根目錄及重新整理報錯404的問題解決
下一篇: 5-4-1IO核心子系統學習目标：學習内容：0.知識總覽1.I/O排程2.裝置保護3.假脫機技術（SPOOLing技術）4.裝置配置設定與回收5.緩沖區管理