- 一、多维数组
- 1.一维数组
- 1.1 数组名
- 1.2 指针和数组是等价的吗？
- 1.3 下标的引用
- 1.4 数组下标可以为负值吗
- 1.5 数组和指针
- 1.6 作为函数参数的数组名
- 2.多维数组
- 2.1 二维数组的初始化
- 2.2 二维数组名
- 2.3 二维数组的3种形式参数
- 3.总结
- 3.1 编程提示
- 3.2 内容总结
- 二、结构体
- 1.结构体基础知识
- 1.1结构体类型的定义
- 1.2 结构体变量的定义
- 1.3 结构体变量的初始化
- 1.4 结构体成员的使用
- 1.5 结构体赋值
- 1.5.1 赋值基本概念
- 1.5.1 深拷贝和浅拷贝
- 1.6 结构体数组
- 2 结构体嵌套指针
- 2.1 结构体嵌套一级指针
- 2.2 结构体嵌套二级指针
- 3.结构体成员偏移量
- 4.结构体字节对齐
- 4.1 内存对齐
- 4.1.1 内存对齐原因
- 4.1.2 如何内存对齐
- 结构体对齐原则：
- 手动设置对齐模数:
- 4.2 内存对齐案例
- 5.快速计算结构体的内存
- 三、总结
- 1 .一维数组名
- 2. 数组指针的定义方式
- 3 二维数组名
- 4 指针数组排序
- 5 结构体基本概念
- 6 结构体深浅拷贝
- 7 结构体嵌套一级指针练习
元素类型角度：数组是相同类型的变量的有序集合
内存角度：连续的一大片内存空间
在讨论多维数组之前，我们还需要学习很多关于一维数组的知识。首先让我们学习一个概念。
考虑下面这些声明：
int a; int b[10];
我们把a称作标量，因为它是个单一的值，这个变量是的类型是一个整数。我们把b称作数组，因为它是一些值的集合。下标和数名一起使用，用于标识该集合中某个特定的值。例如，b[0]表示数组b的第1个值，b[4]表示第5个值。每个值都是一个特定的标量。
那么问题是b的类型是什么？它所表示的又是什么？一个合乎逻辑的答案是它表示整个数组，但事实并非如此。在C中，在几乎所有数组名的表达式中，数组名的值是一个指针常量，也就是数组第一个元素的地址。它的类型取决于数组元素的类型：如果他们是int类型，那么数组名的类型就是“指向int的常量指针”；如果它们是其他类型，那么数组名的类型也就是“指向其他类型的常量指针”。
1.2 指针和数组是等价的吗？答案是否定的。数组名在表达式中使用的时候，编译器才会产生一个指针常量。那么数组在什么情况下不能作为指针常量呢？在以下两种场景下：
（1）当数组名作为sizeof *** 作符的 *** 作数的时候，此时sizeof返回的是整个数组的长度，而不是指针数组指针的长度。
（2）当数组名作为& *** 作符的 *** 作数的时候，此时返回的是一个指向数组的指针，而不是指向某个数组元素的指针常量。对数组名取地址时，得到的是一个数组指针，步长是数组的长度。
void test_1()
{
int arr[5]={1,2,3,4,5};
printf("sizeof(arr)=%dn",sizeof(arr));
//printf("&arr type is %sn",typeid(&arr));
printf("&arr = %dn",&arr);
printf("&arr+1 = %dn",&arr+1);
}
1.3 下标的引用
int arr[] = { 1, 2, 3, 4, 5};
*(arr + 3) ,这个表达式是什么意思呢？
首先，我们说数组在表达式中是一个指向整型的指针，所以此表达式表示arr指针向后移动了3个元素的长度。然后通过间接访问 *** 作符从这个新地址开始获取这个位置的值。这个和下标的引用的执行过程完全相同。所以如下表达式是等同的：
*(arr + 3) arr[3]1.4 数组下标可以为负值吗
int arr[5]={1,2,3,4,5};
int *p = arr+3;
printf("*p=%dn",*p);
printf("*(p-1)=%dn",*(p-1));
printf("p[-1]=%dn",p[-1]);
数组的下标可以为负值，那么是用下标还是指针来 *** 作数组呢？对于大部分人而言，下标的可读性会强一些。
1.5 数组和指针指针和数组并不是相等的。为了说明这个概念，请考虑下面两个声明：
int a[10]; int *b;
（1）声明一个数组时，编译器根据声明所指定的元素数量为数组分配内存空间，然后再创建数组名，指向这段空间的起始位置。
（2）声明一个指针变量的时候，编译器只为指针本身分配内存空间，并不为任何整型值分配内存空间，指针并未初始化指向任何现有的内存空间。
（3）因此，表达式 * a 是完全合法的，但是表达式*b却是非法的。*b将访问内存中一个不确定的位置，将会导致程序终止。另一方面b++可以通过编译，a++（a=a+1）却不行，因为a是一个常量值，指向了数组占用的空间的起始位置，这个空间确定了，这个起始的位置就确定了，所以a 是个常量。
1.6 作为函数参数的数组名当一个数组名作为一个参数传递给一个函数的时候发生什么情况呢？
我们现在知道 数组名其实就是一个指向数组第1个元素的指针，所以很明白此时传递给函数的是一份指针的拷贝。所以函数的形参实际上是一个指针。但是为了使程序员新手容易上手一些，编译器也接受数组形式的函数形参。因此下面两种函数原型是相等的：
int print_array(int *arr); int print_array(int arr[]);
我们可以使用任何一种声明，但哪一个更准确一些呢？答案是指针。因为实参实际上是个指针，而不是数组。
同样 将arr传给了被调用函数后，在被调用函数中sizeof arr值是指针的长度，而不是数组的长度。
现在我们清楚了，为什么一维数组中无须写明它的元素数目了，因为形参只是一个指针，并不需要为数组参数分配内存。另一方面，这种方式使得函数无法知道数组的长度。如果函数需要知道数组的长度，它必须显式传递一个长度参数给函数。
2.多维数组如果某个数组的维数不止1个，它就被称为多维数组。接下来的案例讲解以二维数组举例。
2.1 二维数组的初始化一般有三种方式：
（1）int arr1[3][3] = {
{ 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 }
};
（2）int arr2[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
（3）int arr3[][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
2.2 二维数组名
一维数组名的值是一个指针常量，它的类型是“指向元素类型的指针”，它指向数组的第1个元素。多维数组也是同理，多维数组的数组名也是指向第一个元素，只不过第一个元素是一个数组,或者说二维数组的数组名指向的是第一行的元素。例如：
int arr[3][10]
可以理解为这是一个一维数组，包含了3个元素，只是每个元素恰好是包含了10个元素的数组。arr就表示指向它的第1个元素的指针，所以arr是一个指向了包含了10个整型元素的数组的指针。
2.3 二维数组的3种形式参数//二维数组的第一种形式
void PrintArray01(int arr[3][3]){
for (int i = 0; i < 3; i++){
for (int j = 0; j < 3; j++){
printf("arr[%d][%d]:%dn", i, j, arr[i][j]);
}
}
}
//二维数组的第二种形式
void PrintArray02(int arr[][3]){
for (int i = 0; i < 3; i++){
for (int j = 0; j < 3; j++){
printf("arr[%d][%d]:%dn", i, j, arr[i][j]);
}
}
}
//二维数组的第二种形式
void PrintArray03(int(*arr)[3]){
for (int i = 0; i < 3; i++){
for (int j = 0; j < 3; j++){
printf("arr[%d][%d]:%dn", i, j, arr[i][j]);
}
}
}
void test(){
int arr[][3] = {
{ 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 }
};
PrintArray01(arr);
PrintArray02(arr);
PrintArray03(arr);
}
3.总结
3.1 编程提示
源代码的可读性几乎总是比程序的运行时效率更为重要
只要有可能，函数的指针形参都应该声明为const
在多维数组的初始值列表中使用完整的多层花括号提高可读性
3.2 内容总结在绝大多数表达式中，数组名的值是指向数组第1个元素的指针。这个规则只有两个例外，sizeof和对数组名&。
指针和数组并不相等。当我们声明一个数组的时候，同时也分配了内存。但是声明指针的时候，只分配容纳指针本身的空间。
当数组名作为函数参数时，实际传递给函数的是一个指向数组第1个元素的指针。
我们不单可以创建指向普通变量的指针，也可创建指向数组的指针。
二、结构体 1.结构体基础知识 1.1结构体类型的定义struct Person{
char name[64];
int age;
};
typedef struct _PERSON{
char name[64];
int age;
}Person;
注意：声明结构体类型时不要直接给成员赋值，结构体只是一个类型，编译器还没有为其分配空间，只有根据其类型定义变量时，才分配空间，有空间后才能赋值。
1.2 结构体变量的定义struct Person{
char name[64];
int age;
}p1; //定义类型同时定义变量
struct{
char name[64];
int age;
}p2; //定义类型同时定义变量
struct Person p3; //通过类型直接定义
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.4 结构体成员的使用
struct Person{
char name[64];
int age;
};
void test(){
//在栈上分配空间
struct Person p1;
strcpy(p1.name, "John");
p1.age = 30;
//如果是普通变量，通过点运算符 *** 作结构体成员
printf("Name:%s Age:%dn", p1.name, p1.age);
//在堆上分配空间
struct Person* p2 = (struct Person*)malloc(sizeof(struct Person));
strcpy(p2->name, "Obama");
p2->age = 33;
//如果是指针变量，通过-> *** 作结构体成员
printf("Name:%s Age:%dn", p2->name, p2->age);
}
1.5 结构体赋值
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:%dn", p1.name, p1.age);
printf("Name:%s Age:%dn", p2.name, p2.age);
//将p2的值赋值给p1
p1 = p2;
printf("Name:%s Age:%dn", p1.name, p1.age);
printf("Name:%s Age:%dn", p2.name, p2.age);
}
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.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:%dn",p1[i].name,p1[i].age);
}
printf("-----------------n");
for (int i = 0; i < 3; i++){
printf("Name:%s Age:%dn", 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:%dn", p3[i].name, p3[i].age);
}
}
2 结构体嵌套指针
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:%dn",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);
}
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);
}
3.结构体成员偏移量
//一旦结构体定义下来，则结构体中的成员内存布局就定下了 #include4.结构体字节对齐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); }
在用sizeof运算符求算某结构体所占空间时，并不是简单地将结构体中所有元素各自占的空间相加，这里涉及到内存字节对齐的问题。
从理论上讲，对于任何变量的访问都可以从任何地址开始访问，但是事实上不是如此，实际上访问特定类型的变量只能在特定的地址访问，这就需要各个变量在空间上按一定的规则排列， 而不是简单地顺序排列，这就是内存对齐。
4.1 内存对齐 4.1.1 内存对齐原因 我们知道内存的最小单元是一个字节，当cpu从内存中读取数据的时候，是一个一个字节读取，所以内存对我们应该是入下图这样：
但是实际上cpu将内存当成多个块，每次从内存中读取一个块，这个块的大小可能是2、4、8、16等，
那么下面，我们来分析下非内存对齐和内存对齐的优缺点在哪？
内存对齐是 *** 作系统为了提高访问内存的策略。 *** 作系统在访问内存的时候，每次读取一定长度(这个长度是 *** 作系统默认的对齐数，或者默认对齐数的整数倍)。如果没有对齐，为了访问一个变量可能产生二次访问。
至此大家应该能够简单明白，为什么要简单内存对齐？
（1）提高存取数据的速度。比如有的平台每次都是从偶地址处读取数据，对于一个int型的变量，若从偶地址单元处存放，则只需一个读取周期即可读取该变量；但是若从奇地址单元处存放，则需要2个读取周期读取该变量。
（2）某些平台只能在特定的地址处访问特定类型的数据，否则抛出硬件异常给 *** 作系统。
4.1.2 如何内存对齐（1）对于标准数据类型，它的地址只要是它的长度的整数倍。
（2）对于非标准数据类型，比如结构体，要遵循一下对齐原则：
结构体对齐原则：1）. 数组成员对齐规则。第一个数组成员应该放在offset为0的地方，以后每个数组成员应该放在offset为min（当前成员的大小，#pargama pack(n)）整数倍的地方开始（比如int在32位机器为４字节，#pargama pack(2)，那么从2的倍数地方开始存储）。
2）. 结构体总的大小，也就是sizeof的结果，必须是 min（结构体内部最大成员，#pargama pack(n)） 的整数倍（在结构体内部最大成员，#pargama pack(n)里，取小值），不足要补齐。
3）. 结构体做为成员的对齐规则。如果一个结构体B里嵌套另一个结构体A,还是以最大成员类型的大小对齐，但是结构体A的起点为A内部最大成员的整数倍的地方。（struct B里存有struct A，A里有char，int，double等成员，那A应该从8的整数倍开始存储。），结构体A中的成员的对齐规则仍满足原则1、原则2。
手动设置对齐模数: （1）#pragma pack(show)
显示当前packing alignment的字节数，以warning message的形式被显示。
（2）#pragma pack(push)
将当前指定的packing alignment数组进行压栈 *** 作，这里的栈是the internal compiler stack,同事设置当前的packing alignment为n；如果n没有指定，则将当前的packing alignment数组压栈。
（3）#pragma pack(pop)
从internal compiler stack中删除最顶端的reaord; 如果没有指定n,则当前栈顶record即为新的packing alignement数值；如果指定了n，则n成为新的packing alignment值
（4） #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:%dn",sizeof(Student));
//Student2
//a从偏移量为0位置开始
//b从偏移量为Student内部最大成员整数倍开始，也就是8开始
//c从8的整数倍地方开始,也就是32开始
//所以结构体Sutdnet2内部对齐之后的大小为：40 ， 由于结构体中最大成员为8，必须为8的整数倍 所以大小为40
printf("sizeof Student2:%dn", sizeof(Student2));
}
5.快速计算结构体的内存
在前面的文章里面，有我自己理解的方法，这个方法不一定完全正确，但是到目前没有出现错误。下面的这篇文章是我自己整理，那篇文章中的标题 2.4 结构体的大小和内存结构，写有如何计算结构体的方法，这里就不赘述了。
https://blog.csdn.net/qq_43403759/article/details/121341964三、总结 1 .一维数组名
1.1 除了两种特殊情况外，都是指向数组第一个元素的指针
1.1.1 特殊情况1 sizeof 统计数组长度
1.1.2 特殊情况2 对数组名取地址，数组指针，步长整个数组长度
1.2 数组名是指针常量，指针的指向不可以修改的，而指针指向的值可以改
1.3 传参数时候，int arr[] 可读性更高
1.4 数组索引下标可以为负数
2.1 先定义出数组类型，再通过类型定义数组指针变量
2.1.1 typedef int(ARRARY_TYPE)[5];//ARRARY_TYPE 代表存放5个int类型元素的数组 的数组类型
2.2 先定义数组指针类型，再通过类型定义数组指针变量
2.2.1 typedef int(ARRARY_TYPE)[5];
2.3 直接定义数组指针变量
2.3.1 int( p )[5] = &arr;
3.1 二维数组名 除了两种特殊情况外，是指向第一个一维数组的 数组指针
3.2 两种特殊情况
3.2.1 sizeof 统计二维数组大小
3.2.2 对数组名称取地址 int(*p)[3][3] = &arr
3.3 二维数组做函数参数
3.3.1 //void printArray(int (*array)[3], int row, int col)
3.3.2 //void printArray(int array[][3], int row ,int col)
3.3.3 void printArray(int array[3][3], int row ,int col) 可读性比较高
3.4 数组指针 和 指针数组？
3.4.1 数组指针： 指向数组的指针
3.4.2 指针数组： 由指针组成数组
4.1 选择排序
4.1.1 例如从小到大
4.1.2 开始认定最小值下标为i，从j = i+1的位置起找真实最小值下标，如果计算的真实最小值下标与i不等，互换元素
4.2 利用选择排序实现 指针数组 从大到小排序
4.2.1 字符串对比
4.2.2 if ( strcmp(pArr[max],pArr[j]) == -1)
5.1 加typedef 可以给结构体起别名
5.2 不加typedef ，可以直接创建一个结构体变量
5.3 结构体声明 可以是匿名
5.4 在栈上创建和在堆区创建结构体
5.5 在栈上和堆区创建结构体变量数组
6.1 系统提供的赋值 *** 作是 浅拷贝 – 简单值拷贝，逐字节拷贝
6.2 如果结构体中有属性 创建在堆区，就会出现问题，在释放期间，一段内存重复释放，一段内存泄露
6.3 解决方案：自己手动去做赋值 *** 作，提供深拷贝
7.1 在堆区创建一个 结构体指针数组
7.1.1 malloc(sizeof(struct Person *) *3 )
7.2 在堆区创建出结构体变量
7.2.1 malloc(sizeof(struct Person))
7.3 在堆区创建出具体姓名
7.3.1 malloc(sizeof(char )*64)；
7.4 打印数据
7.5 释放数组
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）