C语言高级专题（6）------- 字符串和结构体

最新推荐文章于 2023-09-28 12:08:08 发布

big__C

最新推荐文章于 2023-09-28 12:08:08 发布

阅读量1k

点赞数

分类专栏： # C语言专题文章标签：字符串结构体对齐 container_of宏 offsetof宏

本文链接：https://blog.csdn.net/qq_45544223/article/details/105523758

版权

C语言专题专栏收录该内容

12 篇文章 8 订阅

订阅专栏

一，字符串

1、C语言没有原生字符串类型

(1)很多高级语言像java、C#等就有字符串类型，有个String来表示字符串，用法和int这些很像，可以String s1 = “linux”;来定义字符串类型的变量。
(2)C语言没有String类型，C语言中的字符串是通过字符指针来间接实现的。

2、C语言使用指针来管理字符串

(1)C语言中定义字符串方法：char *p = "linux";此时p就叫做字符串，但是实际上p只是一个字符指针（本质上就是一个指针变量，只是p指向了一个字符串的起始地址而已）。

3、C语言中字符串的本质：指针指向头、固定尾部的地址相连的一段内存

(1)字符串就是一串字符。字符反映在现实中就是文字、符号、数字等人用来表达的字符，反映在编程中字符就是字符类型的变量。C语言中使用ASCII编码对字符进行编程，编码后可以用char型变量来表示一个字符。字符串就是多个字符打包在一起共同组成的。
(2)字符串在内存中其实就是多个字节连续分布构成的（类似于数组，字符串和字符数组非常像）
(3)C语言中字符串有3个核心要点：第一是用一个指针指向字符串头；第二是固定尾部（字符串总是以’\0’来结尾）；第三是组成字符串的各字符彼此地址相连。
(4)’\0’是一个ASCII字符，其实就是编码为0的那个字符（真正的0，和数字0是不同的，数字0有它自己的ASCII编码）。要注意区分’\0’和’0’和0.（0等于’\0’，'0’等于48）
(5)’\0’作为一个特殊的数字被字符串定义为结尾标志。产生的副作用就是：字符串中无法包含’\0’这个字符。（C语言中不可能存在一个包含’\0’字符的字符串），这种思路就叫“魔数”（魔数就是选出来的一个特殊的数字，这个数字表示一个特殊的含义，你的正式内容中不能包含这个魔数作为内容）。

4、注意：指向字符串的指针和字符串本身是分开的两个东西

(1)char *p = “linux”;在这段代码中，p本质上是一个字符指针，占4字节；"linux"分配在代码段，占6个字节；实际上总共耗费了10个字节，这10个字节中：4字节的指针p叫做字符串指针（用来指向字符串的，理解为字符串的引子，但是它本身不是字符串），5字节的用来存linux这5个字符的内存才是真正的字符串，最后一个用来存’\0’的内存是字符串结尾标志（本质上也不属于字符串）。

5、存储多个字符的2种方式：字符串和字符数组

(1)我们有多个连续字符（典型就是linux这个字符串）需要存储，实际上有两种方式：第一种就是字符串；第二种是字符数组。

6.1、字符数组初始化与sizeof、strlen

(1)sizeof是C语言的一个关键字，也是C语言的一个运算符（sizeof使用时是sizeof(类型或变量名)，所以很多人误以为sizeof是函数，其实不是），sizeof运算符用来返回一个类型或者是变量所占用的内存字节数。为什么需要sizeof？主要原因一是int、double等原生类型占几个字节和平台有关；二是C语言中除了ADT之外还有UDT，这些用户自定义类型占几个字节无法一眼看出，所以用sizeof运算符来让编译器帮忙计算。
(2)strlen是一个C语言库函数，这个库函数的原型是size_t strlen(const char *s);这个函数接收一个字符串的指针，返回这个字符串的长度（以字节为单位）。注意一点是：strlen返回的字符串长度是不包含字符串结尾的’\0’的。我们为什么需要strlen库函数？因为从字符串的定义（指针指向头、固定结尾、中间依次相连）可以看出无法直接得到字符串的长度，需要用strlen函数来计算得到字符串的长度。
(3)sizeof(数组名)得到的永远是数组的元素个数（也就是数组的大小），和数组中有无初始化，初始化多、少等是没有关系的；strlen是用来计算字符串的长度的，只能传递合法的字符串进去才有意义，如果随便传递一个字符指针，但是这个字符指针并不是字符串是没有意义的。
(4)当我们定义数组时如果没有明确给出数组大小，则必须同时给出初始化式，编译器会根据初始化式去自动计算数组的大小（数组定义时必须给出大小，要么直接给，要么给初始化式）

	char a[5] = "windows";
	printf("sizeof(a) = %d.\n", sizeof(a));		// 5
	printf("strlen(a) = %d.\n", strlen(a));		// 5
	
	char *p = "linuxddd";
	printf("sizeof(p) = %d.\n", sizeof(p));		// 4
	printf("strlen(p) = %d.\n", strlen(p));		// 8

6.2、字符串初始化与sizeof、strlen

(1)char *p = "linux"; sizeof(p)得到的永远是4，因为这时候sizeof测的是字符指针p本身的长度，和字符串的长度是无关的。
(2)strlen刚好用来计算字符串的长度。

自己实现一个strlen函数

int mystrlen(const char *p)
{
	int cnt = 0;
	while (*p++ != '\0')
	{
		cnt++;
	}
	return cnt;
}

6.3、字符数组与字符串的本质差异（内存分配角度）

(1)字符数组char a[] = “linux”;来说，定义了一个数组a，数组a占6字节，右值"linux"本身只存在于编译器中，编译器将它用来初始化字符数组a后丢弃掉（也就是说内存中是没有"linux"这个字符串的）；这句就相当于是：char a[] = {'l', 'i', 'n', 'u', 'x', '\0'};
(2)字符串char *p = “linux”;定义了一个字符指针p，p占4字节，分配在栈上；同时还定义了一个字符串"linux"，分配在代码段；然后把代码段中的字符串（一共占6字节）的首地址（也就是’l’的地址）赋值给p。

总结对比：字符数组和字符串有本质差别。

字符数组本身是数组，数组自身自带内存空间，可以用来存东西（所以数组类似于容器）；
而字符串本身是指针，本身永远只占4字节，而且这4个字节还不能用来存有效数据，所以只能把有效数据存到别的地方，然后把地址存在p中。也就是说字符数组自己存那些字符；字符串一定需要额外的内存来存那些字符，字符串本身只存真正的那些字符所在的内存空间的首地址。

二，结构体

1、结构体类型是一种自定义类型

(1)C语言中的2种类型：原生类型和自定义类型。

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

(1)结构体定义时需要先定义结构体类型，然后再用类型来定义变量。
(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、从数组到结构体的进步之处

(1)结构体可以认为是从数组发展而来的。其实数组和结构体都算是数据结构的范畴了，数组就是最简单的数据结构、结构体比数组更复杂一些，链表、哈希表之类的比结构体又复杂一些；二叉树、图等又更复杂一些。
(2)数组有2个明显的缺陷：第一个是定义时必须明确给出大小，且这个大小在以后不能再更改；第二个是数组要求所有的元素的类型必须一致。更复杂的数据结构中就致力于解决数组的这两个缺陷。
(3)结构体是用来解决数组的第二个缺陷的，可以将结构体理解为一个其中元素类型可以不相同的数组。结构体完全可以取代数组，只是在数组可用的范围内数组比结构体更简单。

4、结构体变量中的元素如何访问？

(1)数组中元素的访问方式：表面上有2种方式（数组下标方式和指针方式）；实质上都是指针方式访问。
(2)结构体变量中的元素访问方式：只有一种，用.或者->的方式来访问。（.和->访问结构体元素其实质是一样的，只是C语言规定用结构体变量来访问元素用. 用结构体变量的指针来访问元素用->。实际上在高级语言中已经不区分了，都用.）
(3)结构体的访问方式有点类似于数组下标的方式

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

1.结构体的对齐访问

1、举例说明什么是结构体对齐访问

(1)上节讲过结构体中元素的访问其实本质上还是用指针方式，结合这个元素在整个结构体中的偏移量和这个元素的类型来进行访问的。

//定义一个结构体
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.\n", *p1);			// t
	
	int *p2 = (int *)((int)&s1 + 1);		
	printf("*p2 = %d.\n", *p2);			// 201852036.得到一个奇怪的数字
	
	int *p3 = (int *)((int)&s1 + 4);		
	printf("*p3 = %d.\n", *p3);			// 12.
	
	
	printf("sizeof(struct s) = %d.\n", sizeof(struct s)); 结果是8
	
	return 0;

}

(2)但是实际上结构体的元素的偏移量比我们上节讲的还要复杂，因为结构体要考虑元素的对齐访问，所以每个元素时间占的字节数和自己本身的类型所占的字节数不一定完全一样。（譬如char c实际占字节数可能是1，也可以是2，也可能是3，也可以能4····）
(3)一般来说，我们用.（点）的方式来访问结构体元素时，我们是不用考虑结构体的元素对齐的。因为编译器会帮我们处理这个细节。但是因为C语言本身是很底层的语言，而且做嵌入式开发经常需要从内存角度，以指针方式来处理结构体及其中的元素，因此还是需要掌握结构体对齐规则。

2、结构体为何要对齐访问

(1)结构体中元素对齐访问主要原因是为了配合硬件，也就是说硬件本身有物理上的限制，如果对齐排布和访问会提高效率，否则会大大降低效率。
(2)内存本身是一个物理器件（DDR内存芯片，SoC上的DDR控制器），本身有一定的局限性：如果内存每次访问时按照4字节对齐访问，那么效率是最高的；如果你不对齐访问效率要低很多。
(3)还有很多别的因素和原因，导致我们需要对齐访问。譬如Cache的一些缓存特性，还有其他硬件（譬如MMU、LCD显示器）的一些内存依赖特性，所以会要求内存对齐访问。
(4)对比对齐访问和不对齐访问：对齐访问牺牲了内存空间，换取了速度性能；而非对齐访问牺牲了访问速度性能，换取了内存空间的完全利用。

3、结构体对齐的规则和运算

(1)编译器本身可以设置内存对齐的规则，有以下的规则需要记住：
第一个：32位编译器，一般编译器默认对齐方式是4字节对齐。

总结下：结构体对齐的分析要点和关键：

1、结构体对齐要考虑：结构体整体本身必须安置在4字节对齐处，结构体对齐后的大小必须4的倍数（编译器设置为4字节对齐时，如果编译器设置为8字节对齐，则这里的4是8）
2、结构体中每个元素本身都必须对其存放，而每个元素本身都有自己的对齐规则。
3、编译器考虑结构体存放时，以满足以上2点要求的最少内存需要的排布来算。

4.结构体对齐实例

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.\n", 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.\n", 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.\n", 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.\n", sizeof(struct stu));  //20
	return 0;
}

在这里插入图片描述

5、gcc支持但不推荐的对齐指令：

#pragma pack()   
#pragma pack(n) (n=1/2/4/8)

(1)#pragma是用来指挥编译器，或者说设置编译器的对齐方式的。32位编译器的默认对齐方式是4，但是有时候我不希望对齐方式是4，而希望是别的（譬如希望1字节对齐，也可能希望是8，甚至可能希望128字节对齐）。
(2)常用的设置编译器编译器对齐命令有2种：第一种是#pragma pack()，这种就是设置编译器1字节对齐也叫取消编译器对齐访问；第二种是#pragma pack(4)，这个括号中的数字就表示我们希望多少字节对齐。
(3)我们需要#prgama pack(n)开头，以#pragma pack()结尾，定义一个区间，这个区间内的对齐参数就是n。
(4)#prgama pack的方式在很多C环境下都是支持的，但是gcc虽然也可以不过不建议使用。

#pragma pack(1)

struct mystruct1
{					// 1字节对齐	
    int a;			// 4			
    char b;			// 1			
    short c;		// 2			
};

#pragma pack()

int main()
{
	printf("sizeof(struct mystruct1) = %d.\n", sizeof(struct mystruct1));  //7
	return 0;
}

6、gcc推荐的对齐指令 注意是双下划线，双括号

__attribute__((packed)) ，__attribute__((aligned(n)))

(1)__attribute__((packed))使用时直接放在要进行内存对齐的类型定义的后面，然后它起作用的范围只有加了这个东西的这一个类型。packed的作用就是取消对齐访问。

struct mystruct11
{					      // 1字节对齐	
    int a;			      // 4			
    char b;			      // 1		
    short c;		      // 2			
}__attribute__((packed));



int main()
{
	printf("sizeof(struct mystruct11) = %d.\n", sizeof(struct mystruct11));  //7
	return 0;
}

(2)__attribute__((aligned(n)))使用时直接放在要进行内存对齐的类型定义的后面，然后它起作用的范围只有加了这个东西的这一个类型。它的作用是让整个结构体变量整体进行n字节对齐（注意是结构体变量整体n字节对齐，而不是结构体内各元素也要n字节对齐）

typedef struct mystruct111
{					// 1字节对齐	   4字节对齐		    2字节对齐
    int a;			// 4			4				4
    char b;			// 1			2(1+1)			2
    short c;		// 2			2				2
	short d;		// 2			4(2+2)			2
}__attribute__((aligned(1024))) My111;


int main()
{
	printf("sizeof(struct mystruct111) = %d.\n", sizeof(My111)); //1024
	return 0;
}

2.有关结构体的两个宏：offsetof宏与container_of宏

1、由结构体指针进而访问各元素的原理

(1)通过结构体整体变量来访问其中各个元素，形式上是通过.的方式来访问的，本质上是通过指针方式来访问的，（这时候其实是编译器帮我们自动计算了偏移量）。

2、offsetof宏：

(1)offsetof宏的作用是：用宏来计算结构体中某个元素和结构体首地址的偏移量（其实质是通过编译器来帮我们计算）。

(2)学习思路：第一步先学会用offsetof宏

#include <stdio.h>

struct mystruct  
{                   // 偏移量
	char a;			// 0
	int b;			// 4
	short c;		// 8
};

// TYPE是结构体类型，MEMBER是结构体中一个元素的元素名
// 这个宏返回的是member元素相对于整个结构体变量的首地址的偏移量，类型是int
#define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)

int main(void)
{
	struct mystruct s1;        //先定义一个结构体变量
	s1.b = 12;                  //用.的方式访问
	
	int *p = (int *)((char *)&s1 + 4);       //用.访问的实质还是编译器里面用指针访问
	printf("*p = %d.\n", *p);                //12
	
	int offsetofa = offsetof(struct mystruct, a); //元素a对于整个结构体的偏移量     
	printf("offsetofa = %d.\n", offsetofa);        //0
	
	int offsetofb = offsetof(struct mystruct, b);   //元素a对于整个结构体的偏移量  
	printf("offsetofb = %d.\n", offsetofb);			//4
	
	int offsetofc = offsetof(struct mystruct, c);   //元素a对于整个结构体的偏移量  
	printf("offsetofc = %d.\n", offsetofc);			//8
	
	printf("整个结构体变量的首地址：%p.\n", &s1);    //0xbfaf1284
	printf("s1.b的首地址：%p.\n", &(s1.b)); 		//0xbfaf1288
	printf("偏移量是：%d.\n", (char *)&(s1.b) - (char *)&s1);   //4

		
	return 0;
}

第二步再去理解这个宏的实现原理

(TYPE *)0

这是一个强制类型转换，把0地址强制类型转换成一个指针，这个指针指向一个TYPE类型的结构体变量。
((TYPE *)0)->MEMBER

(TYPE *)0是一个TYPE类型结构体变量的指针，通过指针指针来访问这个结构体变量的member元素
&((TYPE *)0)->MEMBER

等效于&(((TYPE *)0)->MEMBER)，意义就是得到member元素的地址。但是因为整个结构体变量的首地址是0，所以就得到了成员的偏移量。

3、container_of宏：

#define container_of(ptr, type, member) \
({	const typeof(((type *)0)->member) * __mptr = (ptr); (type *)((char *)__mptr - offsetof(type, member)); })

先学会使用这个宏

#include <stdio.h>

struct mystruct
{
	char a;			
	int b;			
	short c;	
};

// TYPE是结构体类型，MEMBER是结构体中一个元素的元素名
// 这个宏返回的是member元素相对于整个结构体变量的首地址的偏移量，类型是int
#define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)

// ptr是指向结构体元素member的指针，type是结构体类型，member是结构体中一个元素的元素名
// 这个宏返回的就是指向整个结构体变量的指针，类型是(type *)
#define container_of(ptr, type, member) ({			\
	const typeof(((type *)0)->member) * __mptr = (ptr);	\
	(type *)((char *)__mptr - offsetof(type, member)); })

int main(void)
{
	struct mystruct s1;
	struct mystruct *pS = NULL;    //用于接收返回的结构体的指针
	
	short *p = &(s1.c);		// p就是指向结构体中某个member的指针
	
	printf("s1的指针等于：%p.\n", &s1);       //0xbfe88374.

	// 问题是要通过p来计算得到s1的指针
	pS = container_of(p, struct mystruct, c);
	printf("pS等于：%p.\n", pS);            //0xbfe88374.

	return 0;
	
}

#define container_of(ptr, type, member) \
({	const typeof(((type *)0)->member) * __mptr = (ptr); (type *)((char *)__mptr - offsetof(type, member)); })

ptr是指向结构体元素member的指针，type是结构体类型，member是结构体中一个元素的元素名
这个宏返回的就是指向整个结构体变量的指针，类型是(type *)
(1)作用：知道一个结构体中某个元素的指针，反推这个结构体变量的指针。有了container_of宏，我们可以从一个元素的指针得到整个结构体变量的指针，继而得到结构体中其他元素的指针。
(2)typeof关键字的作用是：typepef(a)时由变量a得到a的类型，typeof就是由变量名得到变量数据类型的。
(3)这个宏的工作原理：先用typeof得到member元素的类型定义成一个指针，然后用这个指针减去该元素相对于整个结构体变量的偏移量（偏移量用offsetof宏得到的），减去之后得到的就是整个结构体变量的首地址了，再把这个地址强制类型转换为type *即可。

big__C

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
1
评论
C语言高级专题（6）------- 字符串和结构体

字符串1、C语言没有原生字符串类型(1)很多高级语言像java、C#等就有字符串类型，有个String来表示字符串，用法和int这些很像，可以String s1 = “linux”;来定义字符串类型的变量。(2)C语言没有String类型，C语言中的字符串是通过字符指针来间接实现的。2、C语言使用指针来管理字符串(1)C语言中定义字符串方法：char *p = “linux”;此时p就叫...
复制链接

扫一扫