C基础之基础数据结构

C基础之基础数据结构

前言

c基础文章连载：
1.C语言关于内存
2.C基础之位操作
3.C指针
4.C基础之函数指针、二重指针
5.C基础之基础数据结构
6.C基础之存储类、作用域、生命周期、链接属性

---

1.C语言的字符串类型

1.1、C语言没有原生字符串类型
(1)很多高级语言像java、C#等就有字符串类型，有个String来表示字符串，用法和int这些很像，可以String s1 = “linux”;来定义字符串类型的变量。
(2)C语言没有String类型，C语言中的字符串是通过字符指针来间接实现的。
1.2、C语言使用指针来管理字符串
(1)C语言中定义字符串方法：char *p = “linux”;此时p就叫做字符串，但是实际上p只是一个字符指针（本质上就是一个指针变量，只是p指向了一个字符串的起始地址而已）。
1.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’字符的字符串），这种思路就叫“魔数”（魔数就是选出来的一个特殊的数字，这个数字表示一个特殊的含义，你的正式内容中不能包含这个魔数作为内容）。
1.4、注意：指向字符串的指针和字符串本身是分开的两个东西
(1)char *p = “linux”;在这段代码中，p本质上是一个字符指针，占4字节；"linux"分配在代码段，占6个字节；实际上总共耗费了10个字节，这10个字节中：4字节的指针p叫做字符串指针（用来指向字符串的，理解为字符串的引子，但是它本身不是字符串），5字节的用来存linux这5个字符的内存才是真正的字符串，最后一个用来存’\0’的内存是字符串结尾标志（本质上也不属于字符串）。
1.5、存储多个字符的2种方式：字符串和字符数组
(1)我们有多个连续字符（典型就是linux这个字符串）需要存储，实际上有两种方式：第一种就是字符串；第二种是字符数组。

2.字符串和字符数组的细节

2.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)当我们定义数组时如果没有明确给出数组大小，则必须同时给出初始化式，编译器会根据初始化式去自动计算数组的大小（数组定义时必须给出大小，要么直接给，要么给初始化式）
strlen内部其实很简单：

#include<stdio.h>
int strlen(const char *p)
{
	int cnt=0;
	while(*p!=’\0’)		//也可以写成p!=0,因为0和’\0’等价
	{					//也可写成	while(*p++!=0)
		cnt++;			//			{cnt++;
		p++;				//			}
	}
	return cnt;
}
int main(void)
{
	char *p="linux";
	printf("%d",strlen(p));
}

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

char *p="linuxy";
printf("%d\n",sizeof(p));			//输出4
printf("%d\n",strlen(p));			//输出6

2.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中。
也就是说字符数组自己存那些字符；字符串一定需要额外的内存来存那些字符，字符串本身只存真正的那些字符所在的内存空间的首地址。
字符串虽然定义比较麻烦，但是可以方便的定义在自己想要存的位置，所以常用。
char b[5];
int main(void)
{ //字符串存在栈
char a[7];
char *p=a;
//字符串存在数据段
char *p=b;
//字符串存在堆空间
char *p=(char *)malloc(5);
}
当用strlen测字符串时，输出字符串长度
测字符数组时，输出字符数组长度（数组名相当于指针）
当用sizeof测字符串时，输出4，为指针的字节数
测字符数组时，输出字符数组长度+1

3.C语言之结构体概述

3.1、结构体类型是一种自定义类型
(1)C语言中的2种类型：原生类型和自定义类型。
3.2、结构体使用时先定义结构体类型再用类型定义变量
(1)结构体定义时需要先定义结构体类型，然后再用类型来定义变量。
(2)也可以在定义结构体类型的同时定义结构体变量:
struct student
{
char name[20];
int age;
}s1;
3.3、从数组到结构体的进步之处
(1)结构体可以认为是从数组发展而来的。其实数组和结构体都算是数据结构的范畴了，数组就是最简单的数据结构、结构体比数组更复杂一些，链表、哈希表之类的比结构体又复杂一些；二叉树、图等又更复杂一些。
(2)数组有2个明显的缺陷：第一个是定义时必须明确给出大小，且这个大小在以后不能再更改；第二个是数组要求所有的元素的类型必须一致。更复杂的数据结构中就致力于解决数组的这两个缺陷。
(3)结构体是用来解决数组的第二个缺陷的，可以将结构体理解为一个其中元素类型可以不相同的数组。结构体完全可以取代数组，只是在数组可用的范围内数组比结构体更简单。
3.4、结构体变量中的元素如何访问？
(1)数组中元素的访问方式：表面上有2种方式（数组下标方式和指针方式）；实质上都是指针方式访问。
(2)结构体变量中的元素访问方式：只有一种，用.或者->的方式来访问。（.和->访问结构体元素其实质是一样的，只是C语言规定用结构体变量来访问元素用. 用结构体变量的指针来访问元素用->。实际上在高级语言中已经不区分了，都用.）
(3)结构体的访问方式有点类似于数组下标的方式
思考：结构体变量的.或者->访问元素的实质是什么？其实本质上还是用指针来访问的。

struct student{
int a;
double b;	
}s1;			
s1.b=4.4;		//这句代码的实质：double *p=(double *)((int)&s1+4);	*p=4.4; 

关于上面代码的解释：
**前面int的一个元素占了4字节,int强制类型转换解释：&s1本身是带类型的，如果不强制类型转换直接加4则相当于&s1地址+4sizeof(s1)，指针之前讲过，+4不是真正的+4，而是+4sizeof(其变量类型)。转换成int类型是因为int是整形，代表一个数，转换成char已经超出范围了，char超出其范围就会转圈，得到一个根本和地址值不相干的值。
虽然只有int类型的数能这样做运算，但是所有指针类型都可以做地址运算，就是偏移量，如：double *p=(double *)((char *)&s1+4);或者double *p=(double )((int )&s1+1);

4.结构体的对齐访问

4.1、举例说明什么是结构体对齐访问
(1)上节讲过结构体中元素的访问其实本质上还是用指针方式，结合这个元素在整个结构体中的偏移量和这个元素的类型来进行访问的。
(2)但是实际上结构体的元素的偏移量比我们上节讲的还要复杂，因为结构体要考虑元素的对齐访问，所以每个元素时间占的字节数和自己本身的类型所占的字节数不一定完全一样。（譬如char c实际占字节数可能是1，也可以是2，也可能是3，也可能4····）
(3)一般来说，我们用.的方式来访问结构体元素时，我们是不用考虑结构体的元素对齐的。因为编译器会帮我们处理这个细节。但是因为C语言本身是很底层的语言，而且做嵌入式开发经常需要从内存角度，以指针方式来处理结构体及其中的元素，因此还是需要掌握结构体对齐规则。
4.2、结构体为何要对齐访问
(1)结构体中元素对齐访问主要原因是为了配合硬件，也就是说硬件本身有物理上的限制，如果对齐排布和访问会提高效率，否则会大大降低效率。
(2)内存本身是一个物理器件（DDR内存芯片，SoC上的DDR控制器），本身有一定的局限性：如果内存每次访问时按照4字节对齐访问，那么效率是最高的；不对齐访问效率要低很多。
(3)还有很多别的因素和原因，导致我们需要对齐访问。譬如Cache的一些缓存特性，还有其他硬件（譬如MMU、LCD显示器）的一些内存依赖特性，所以会要求内存对齐访问。
(4)对比对齐访问和不对齐访问：对齐访问牺牲了内存空间，换取了速度性能；而非对齐访问牺牲了访问速度性能，换取了内存空间的完全利用。
4.3、结构体对齐的规则和运算
(1)编译器本身可以设置内存对齐的规则，有以下的规则需要记住：
第一个：32位编译器，一般编译器默认对齐方式是4字节对齐。

/*分析:首先是整个结构体，整个结构体变量4字节对齐是由编译器保证的，我们不用操心。
然后是第一个元素a,a的开始地址就是整个结构体的开始地址，所以自然是4字节对齐的，但是a的结构地址要有下一个元素说了算。
然后是第二个元素b,因为上一个元素a本身占4字节，本身就是对齐的。所以留给b的开始地址也是4字节对齐地址，所以b可以直接放（b放的位置就决定了a一共占了4字节，因为不需要填充）。
b的起始地址定了后，结束地址不能定（因为可能需要填充），结束地址要看下一个元素来定
然后是第三个元素c,short类型需要2字节对齐（必须放在类似0，2，4，6这样的地址处）
*/
struct mystruct1	
{					//1字节对齐			4字节对齐
	int a;			//4					4
	char b;			//1					2
	short c;			//2					2
};
typedef struct mystruct2	
{					//1字节对齐			4字节对齐
	char a;			//1					4
	int b;			//4					4
	short c;			//2					4
}mys2;					
/*
typedef struct 		//这个形式后面没有结构体名字，所以能用的就是mys3这个名字
{
	int a;
	char b;
	static int c;
}mys3;
*/
typedef struct mystruct5
{
	int a;
	struct mystruct1 s1;
	double b;
	int c;
}mys5;
struct stu
{
	char sex;
	int length;
	char name[10];
};

总结下：结构体对齐的分析要点和关键：
1、结构体对齐要考虑：结构体整体本身必须安置在4字节对齐处，结构体对齐后的大小必须4的倍数（编译器设置为4字节对齐时，如果编译器设置为8字节对齐，则这里的4是8）
2、结构体中每个元素本身都必须对其存放，而每个元素本身都有自己的对齐规则。
3、编译器考虑结构体存放时，以满足以上2点要求的最少内存需要的排布来算。
8.4、gcc支持但不推荐的对齐指令：#pragma pack() #pragma pack(n) (n=1/2/4/8)
(1)#pragma是用来指挥编译器，或者说设置编译器的对齐方式的。编译器的默认对齐方式是4，但是有时候我不希望对齐方式是4，而希望是别的（譬如希望1字节对齐（有些人喜欢讲：设置编译器不对齐访问，还有些讲：取消编译器对齐访问），也可能希望是8，甚至可能希望128字节对齐）。
(2)我们需要#prgama pack(n)开头，以#pragma pack()结尾，定义一个区间，这个区间内的对齐参数就是n。
(3)#prgma pack的方式在很多C环境下都是支持的，但是gcc虽然也可以不过不建议使用。
8.5、gcc推荐的对齐指令__attribute__((packed)) attribute((aligned(n)))
(1)attribute((packed))使用时直接放在要进行内存对齐的类型定义的后面，然后它起作用的范围只有加了这个东西的这一个类型。packed的作用就是取消对齐访问。
(2)attribute((aligned(n)))使用时直接放在要进行内存对齐的类型定义的后面，然后它起作用的范围只有加了这个东西的这一个类型。它的作用是让整个结构体变量整体进行n字节对齐（注意是结构体变量整体n字节对齐，而不是结构体内各元素也要n字节对齐）
8.6、参考阅读blog：
http://www.cnblogs.com/dolphin0520/archive/2011/09/17/2179466.html
http://blog.csdn.net/sno_guo/article/details/8042332

5.共用体union

5.1、共用体类型的定义、变量定义和使用
(1)共用体union和结构体struct在类型定义、变量定义、使用方法上很相似。
(2)共用体和结构体的不同：结构体类似于一个包裹，结构体中的成员彼此是独立存在的，分布在内存的不同单元中，他们只是被打包成一个整体叫做结构体而已；共用体中的各个成员其实是一体的，彼此不独立，他们使用同一个内存单元。可以理解为：有时候是这个元素，有时候是那个元素。更准确的说法是同一个内存空间有多种解释方式。
(3)共用体union就是对同一块内存中存储的二进制的不同的理解方式。
(4)在有些书中把union翻译成联合（联合体），这个名字不好。现在翻译成共用体比较合适。
(5)union的sizeof测到的大小实际是union中各个元素里面占用内存最大的那个元素的大小。因为可以存的下这个就一定能够存的下其他的元素。
(6)union中的元素不存在内存对齐的问题，因为union中实际只有1个内存空间，都是从同一个地址开始的（开始地址就是整个union占有的内存空间的首地址），所以不涉及内存对齐。
5.2、共用体和结构体的相同和不同
(1)相同点就是操作语法几乎相同。
(2)不同点是本质上的不同。struct是多个独立元素（内存空间）打包在一起；union是一个元素（内存空间）的多种不同解析方式。
5.3、共用体的主要用途
(1)共用体就用在那种对同一个内存单元进行多种不同规则解析的这种情况下。
(2)C语言中其实是可以没有共用体的，用指针和强制类型转换如：*((float *)&a)可以替代共用体完成同样的功能，但是共用体的方式更简单、更便捷、更好理解。

6.枚举

6.1、枚举是用来干嘛的？
(1)枚举在C语言中其实是一些符号常量集。直白点说：枚举定义了一些符号，这些符号的本质就是int类型的常量，每个符号和一个常量绑定。这个符号就表示一个自定义的一个识别码，编译器对枚举的认知就是符号常量所绑定的那个int类型的数字。
(2)枚举中的枚举值都是常量，枚举值常量是全局的，怎么验证？
(3)枚举符号常量和其对应的常量数字相对来说，数字不重要，符号才重要。符号对应的数字只要彼此不相同即可，没有别的要求。所以一般情况下我们都不明确指定这个符号所对应的数字，而让编译器自动分配。（编译器自动分配的原则是：从0开始依次增加。如果用户自己定义了一个值，则从那个值开始往后依次增加）
6.2、C语言为何需要枚举
(1)C语言没有枚举是可以的。使用枚举其实就是对1、0这些数字进行符号化编码，这样的好处就是编程时可以不用看数字而直接看符号。符号的意义是显然的，一眼可以看出。而数字所代表的含义除非看文档或者注释。
(2)宏定义的目的和意义是：不用数字而用符号。从这里可以看出：宏定义和枚举有内在联系。宏定义和枚举经常用来解决类似的问题，他们俩基本相当可以互换，但是有一些细微差别。
6.3、宏定义和枚举的区别
(1)枚举是将多个有关联的符号封装在一个枚举中，而宏定义是完全散的。也就是说枚举其实是多选一。
(2)什么情况下用枚举？当我们要定义的常量是一个有限集合时（譬如一星期有7天），最适合用枚举。
(3)不能用枚举的情况下（定义的常量符号之间无关联，或者无限的）用宏定义。
总结：宏定义先出现，用来解决符号常量的问题；后来人们发现有时候定义的符号常量彼此之间有关联（多选一的关系），用宏定义来做虽然可以但是不贴切，于是乎发明了枚举来解决这种情况。