«

C语言结构体与内存对齐方法怎么使用

时间:2024-4-13 16:52     作者:韩俊     分类: Java


今天小编给大家分享一下C语言结构体与内存对齐方法怎么使用的相关知识点,内容详细,逻辑清晰,相信大部分人都还太了解这方面的知识,所以分享这篇文章给大家参考一下,希望大家阅读完这篇文章后有所收获,下面我们一起来了解一下吧。

1.结构体类型

C语言中的2种类型:原生类型和自定义类型,结构体类型是一种自定义类型。

2.结构体使用时先定义结构体类型再用类型定义变量

-> 结构体定义时需要先定义结构体类型,然后再用类型来定义变量。

-> 也可以在定义结构体类型的同时定义结构体变量。

// 定义类型
struct people
{
 char name[20];
 int age;
};
 
// 定义类型的同时定义变量。
struct student
{
 char name[20];
 int age;
}s1;
 
// 将类型struct student重命名为s1,s1是一个类型名,不是变量
typedef struct student
{
 char name[20];
 int age;
}s1;

3.从数组到结构体的进步之处

-> 结构体可以认为是从数组发展而来的。

-> 数组有2个明显的缺陷:第一个是定义时必须明确给出大小,且这个大小在以后不能再更改;第二个是数组要求所有的元素的类型必须一致。

-> 结构体是用来解决数组的第二个缺陷的,可以将结构体理解为一个其中元素类型可以不相同的数组。

4.结构体变量中的元素如何访问?

-> 数组中元素的访问方式:表面上有2种方式(数组下标方式和指针方式);实质上都是指针方式访问。

-> 结构体变量中的元素访问方式:只有一种,用 . 或者->的方式来访问。

struct score
{
 int a;
 int b;
 int c;
};
 
struct myStruct
{
 int a;   // 4 
 double b;  // 8
 char c;
};
 
int  main()
{
 struct myStruct s1;
 s1.a = 12;        // int *p = (int *)&s1; *p = 12;
 s1.b = 4.4;       // double *p = (double *)(&s1 + 4); *p = 4.4;
 s1.c = "a";      // char *p = (char *)((int)&s1 + 12); *p = "a";
 
 int a[3];  // 3个学生的成绩,数组方式
 score s;  // 3个学生的成绩,结构体的方式
 
 s.a = 12;  // 编译器在内部还是转成指针式访问 int *p = s; *(p+0) = 12;
 s.b = 44;  // int *p = s; *(p+1) = 44;
 s.c = 64;  // int *p = s; *(p+2) = 44;
}

5.结构体的对齐访问

什么是结构体对齐访问:

//定义一个结构体
struct s
{
 char c;   //     c实际占4字节,而不是1字节
 int b;   // 4
};
 
int main(void)
{
 struct s s1;
 s1.c = "t";
 s1.b = 12;
 
 char *p1 = (char *)(&s1);
 printf("*p1 = %c.
", *p1);   // t
 
 int *p2 = (int *)((int)&s1 + 1);  
 printf("*p2 = %d.
", *p2);   // 201852036.得到一个奇怪的数字
 
 int *p3 = (int *)((int)&s1 + 4);  
 printf("*p3 = %d.
", *p3);   // 12.
 
 
 printf("sizeof(struct s) = %d.
", sizeof(struct s)); 结果是8
 
 return 0;
 
}

6.结构体为何要对齐访问

-> 结构体中元素对齐访问主要原因是为了配合硬件,也就是说硬件本身有物理上的限制,如果对齐排布和访问会提高效率,否则会大大降低效率。

-> 对比对齐访问和不对齐访问:对齐访问牺牲了内存空间,换取了速度性能;而非对齐访问牺牲了访问速度性能,换取了内存空间的完全利用。

7.结构体对齐实例

struct mystruct1
{     // 1字节对齐     4字节对齐
    int a;   // 4   4
    char b;   // 1   2(1+1)
    short c;  // 2   2
};
 
int main()
{
 printf("sizeof(struct mystruct1) = %d.
", sizeof(struct mystruct1));       //   8
 return 0;
}

分析:首先是整个结构体,整个结构体变量4字节对齐是由编译器保证的,我们不用操心。 第一个元素a,a的开始地址就是整个结构体的开始地址,所以自然是4字节对齐的。但是a的结束地址要由下一个元素说了算。第二个元素b,因为上一个元素a本身占4字节,本身就是对齐的。所以留给b的开始地址也是4字节对齐地址,所以b可以直接放。 b的起始地址定了后,结束地址不能定(因为可能需要填充),结束地址要看下一个元素来定。然后是第三个元素c,short类型需要2字节对齐(short类型元素必须放在类似0,2,4,8这样的地址处,不能放在1,3这样的奇数地址处),因此c不能紧挨着b来存放,解决方案是在b之后添加1 字节的填,然后再开始放c。c放完之后还没结束, 当整个结构体的所有元素都对齐存放后,还没结束,因为整个结构体大小还要是4的整数倍。

typedef struct mystruct2
{                   // 1字节对齐     4字节对齐
    char a;            // 1           4(1+3)
    int b;         // 4           4
    short c;       // 2           4(2+2)
}MyS2;
 
int main()
{
    printf("sizeof(struct mystruct2) = %d.
", sizeof(struct mystruct2));   //12
    return 0;
}
struct mystruct1
{            //1字节对齐    4字节对齐
    int a;          // 4       4
    char b;          // 1       2(1+1)
    short c;         // 2       2
};
 
typedef struct myStruct5
{       // 1字节对齐    4字节对齐
    int a;     // 4   4
    struct mystruct1 s1; // 7   8
    double b;    // 8   8
    int c;     // 4   4 
}MyS5;
 
int main()
{
 printf("sizeof(struct mystruct5) = %d.
", sizeof(MyS5));  //24
 return 0;
}
struct stu
{       // 1字节对齐     4字节对齐
 char sex;    // 1   4(1+3)
 int length;    // 4   4
 char name[10];   // 10   12(10+2)
};
 
 
int main()
{
 printf("sizeof(struct stu) = %d.
", sizeof(struct stu));  //20
 return 0;
}

标签: java

热门推荐