第7讲:指针和结构体(一)(看这一篇知识点够了)

前言:经过一周的沉淀,我把指针和结构体最精华的部分带给大家(加上个人的一些理解),希望能够帮助到大家。

目录:

1 指针是什么?——>指针就是地址

2 有什么用?——>存储变量类型的地址,任何类型的地址都能存在指针里面

3 一阶指针的运用

4 二阶指针的运用

5 指针数组,数组指针

6 指针函数,函数指针

7 结构体的知识

8 指针结构体

9 qsort函数来排序数组类型(各种数组类型的排序)

10 qsort函数的底层原理(用冒泡排序来解释)

3 一阶指针的运用

下面是错误的写法。

问题:指针只能改地址不能改当前位置的内容

第7讲:指针和结构体(一)(看这一篇知识点够了)_第1张图片

正确写法(这里忘记对a变量加&)

第7讲:指针和结构体(一)(看这一篇知识点够了)_第2张图片

只能通过变量来改内容。

通过指针来打印数组

第7讲:指针和结构体(一)(看这一篇知识点够了)_第3张图片

4 二阶指针的运用

错误案例:

这种写法意味着把指针指向的地址为0,不是指向a的地址切记!!!

还有下面的二阶指针的运用也是有错误的,因为你等于把p指向的地址赋给了二阶指针指向的地址,等于还是p指向的地址

第7讲:指针和结构体(一)(看这一篇知识点够了)_第4张图片

一阶指针打印结构体数组内容:

#define _CRT_SECURE_NO_WARNINGS 1
#include
struct Stu
{
	int age;
	char* name;
};
int main()
{
	//数组的元素类型是结构体
	//这里建立数组结构体
	struct Stu arr[3] = { {.name = "zhangsan",.age = 18}, {19,"lisi"}, {20,"wangwu"}};
	struct Stu* p = arr;
	for (int i = 0; i < 3; i++)
	{
		printf("%d,%s\n",arr[i].age,arr[i].name);//这里是打印结构体的格式
		printf("%d,%s\n", p->age,p->name);//指针来打印结构体格式
		p++;
	}
}

第7讲:指针和结构体(一)(看这一篇知识点够了)_第5张图片

二阶指针打印结构体数组(无非套了个壳子而已没有什么大不了的)

这里的*pp就是p,这样大家理解就容易了

但是大家循环下面千万不要写pp++,这个是pp访问的地址+1,而p指针的地址内容是未知的,编译器会编译错误的

#define _CRT_SECURE_NO_WARNINGS 1
#include
struct Stu
{
	int age;
	char* name;
};
int main()
{
	//数组的元素类型是结构体
	//这里建立数组结构体
	struct Stu arr[3] = { {.name = "zhangsan",.age = 18}, {19,"lisi"}, {20,"wangwu"}};
	struct Stu* p = arr;
	struct Stu** pp = &p;
	for (int i = 0; i < 3; i++)
	{
		printf("%d,%s\n",arr[i].age,arr[i].name);
		printf("%d,%s\n", (*pp)->age,(*pp)->name);
		p++;
	}
}

5 指针数组,数组指针

1 指针数组就是数组,数组里面存的是指针变量

格式:(类型)* 数组名[]={  }

2 数组指针是指针,是指针变量,指针指向的是数组的地址

格式:(类型)(* 数组名)[]={  }

这里要看符号结合的优先级,因为数组名与[]结合的优先级大于*数组名,所以我们要把*数组名用括号括起来,这样才能表示一个指针数组

(这两个东西一定要弄清楚,不要搞混淆了)

下面先看看指针数组吧!

int main()
{
	int* arr[5] = { 1,2,3,4,5 };
	int i = 0;
	for (; i < 5; i++)
	{
		printf("%d ", arr[i]);//这个arr[i]的意思就是*(arr+i)
	}
	return 0;
}

这样写也行(是不是很惊讶呢?)

这里解释一下:

数组arr本来就是一个地址,就是首元素的地址,可以理解为一个指针,指向的是int*类型的常量,然后int*类型的指针指向常量1的地址,也就是说*(arr+i)就是int*所指向的内容

int main()
{
	int* arr[5] = { 1,2,3,4,5 };
	int i = 0;
	for (; i < 5; i++)
	{
		printf("%d ", i[arr]);//这个arr[i]的意思就是*(arr+i)
	}
	return 0;
}

第7讲:指针和结构体(一)(看这一篇知识点够了)_第6张图片

下面看看数组指针

#define _CRT_SECURE_NO_WARNINGS 1
#include
struct Stu
{
	int age;
	char* name;
};
int main()
{
	//数组的元素类型是结构体
	//这里建立结构体数组指针
	struct Stu arr[3] = { {.name = "zhangsan",.age = 18},{19,"lisi"} ,{20,"wangwu"}};
	struct Stu(*p)[3] = &arr[0];
	for (int i = 0; i < 3; i++)
	{
		printf("%d,%s\n",(*p)[i].age,(*p)[i].name);
		printf("%d,%s\n", (*p)->age,(*p)->name);
	}
}

第7讲:指针和结构体(一)(看这一篇知识点够了)_第7张图片数组指针对二元数组的应用

#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
	size_t arr[2][2] = {1,2,4,5};
	size_t(*p)[2] = arr;
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 2; j++)
			printf("%d ", p[i][j]);
        printf("\n");
	}
}

第7讲:指针和结构体(一)(看这一篇知识点够了)_第8张图片

6 指针函数,函数指针

指针函数,函数的返回类型是指针类型,用指针接收

函数指针,指针指向函数的地址(函数名就是地址)

指针函数

#define _CRT_SECURE_NO_WARNINGS 1
#include
int* Add(const void* p1,const void* p2)//指针函数
{
	return *(int*)p1 - *(int*)p2;
}
int main()
{
	int a = 0;
	int b = 1;
	printf("%d", Add(&a, &b));
}

第7讲:指针和结构体(一)(看这一篇知识点够了)_第9张图片

函数指针(我们来制作一个计算器,转移表)

#define _CRT_SECURE_NO_WARNINGS 1
#include 
typedef int (*ap)(int, int);//简单的定义函数指针类型名字为ap
int Mul(int x, int y)
{
	return x * y;
}
int Add(int x, int y)
{
	return x + y;
}
int Div(int x, int y)
{
	return x / y;
}
int Sub(int x, int y)
{
	return x - y;
}
int main()
{
	int input = 0;
	do
	{
		int a = 0;
		int b = 0;
		printf("请输入a和b的值:");
		scanf("%d%d", &a, &b);
		printf("*****************************\n");
		printf("******1:乘法	2:加法*******\n");
		printf("******3:除法    4:减法*******\n");
		printf("******0:退出计算器    *******\n");
		printf("*****************************\n");
		printf("请输入你要进行的计算:\n");
		scanf("%d", &input);
		int (*arr[5])(int a,int b) = {NULL,Mul,Add,Div,Sub};
		printf("%d\n", (*arr[input])(a,b));
	} while (input);
	return 0;
}

第7讲:指针和结构体(一)(看这一篇知识点够了)_第10张图片

回调函数:用函数间接调用函数

int Mul(int x, int y)
{
	return x * y;
}
int Add(int x, int y)
{
	return x + y;
}
int Div(int x, int y)
{
	return x / y;
}
int Sub(int x, int y)
{
	return x - y;
}
void Calc(int (*pt)(int, int))
{
	int a = 0;
	int b = 0;
	printf("请输入a和b的值:");
	scanf("%d%d", &a, &b);
	printf("计算的答案:");
	int sum = pt(a, b);
	printf("%d\n", sum);
}
int main()
{
	int input = 0;
	int a = 0;
	int b = 0;
	do
	{
		printf("*****************************\n");
		printf("******1:乘法	2:加法*******\n");
		printf("******3:除法    4:减法*******\n");
		printf("******0:退出计算器    *******\n");
		printf("*****************************\n");
		printf("请输入你要进行的计算:\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Calc(Mul);
			break;
		case 2:
			Calc(Add);
			break;
		case 3:
			Calc(Div);
			break;
		case 4:
			Calc(Sub);
			break;
		case 0:
			printf("退出计算器");
			break;
		}
	} while (input);
	return 0;
}

第7讲:指针和结构体(一)(看这一篇知识点够了)_第11张图片

7 结构体知识点

7—1匿名结构体

错误代码:

struct//没有标签的结构体,叫做匿名结构体,只能用一次
{
	int age;
	char* name;
}s;
int main()
{
	s = { 18,"zhangsan" };

	return 0;
}

第7讲:指针和结构体(一)(看这一篇知识点够了)_第12张图片

一般结构体的表达方式:

struct Stu
{
	int age;
	char* name;
};
int main()
{
	struct Stu s = { 18,"zhangsan" };//结构体变量的创建

	return 0;
}

下面简单用个结构体类型来写一个学生管理系统:

#define _CRT_SECURE_NO_WARNINGS 1
#include 
typedef struct Stu std;
struct Stu
{
	int id;
	int age;
	char* name;
};
int main()
{
	struct Stu arr[3] = { {.id = 123456,.age = 18,.name = "zhangsan"},{123457,19,"lisi"},{123458,20,"wangwu"} };
	
	std a = { .id = 123456,.age = 18,.name = "zhangsan" };
	std b = { 123457,19,"lisi" };
	std c = { 123458,20,"wangwu" };
	std* arr1[3] = { &a,&b,&c };
	for (int i = 0; i < 3; i++)
	{
		printf("%d,%d,%s\n",*arr1[i]);
		printf("%d\n",arr1[i]->id);
	}
}

第7讲:指针和结构体(一)(看这一篇知识点够了)_第13张图片

9 qsort函数来排序数组类型(各种数组类型的排序)

typedef struct Stu std;
struct Stu
{
	int id;
	int age;
	char name[20];
};
//按照学号排序,升序排列
int Cmp(void* p1, void* p2)
{
	return ((std*)p1)->id - ((std*)p2)->id;
}
#include
int main()
{
	struct Stu arr[3] = { {.id = 123456,.age = 18,.name = "zhangsan"},{123457,19,"lisi"},{123458,20,"wangwu"} };
	int num = sizeof(arr) / sizeof(arr[0]);
	int size = sizeof(arr[0]);
	qsort(arr, num, size, Cmp);
	for (int i = 0; i < 3; i++)
	{
		printf("%d,%d,%s\n", arr[i].id,arr[i].age,arr[i].name);
	}
	return 0;
}

第7讲:指针和结构体(一)(看这一篇知识点够了)_第14张图片

按照名字的首字母来排序

typedef struct Stu std;
struct Stu
{
	int id;
	int age;
	char name[20];
};
//按照字母首元素排序
int Cmp(void* p1, void* p2)
{
	return strcmp(((std*)p1)->name,((std*)p2)->name);
}
#include
int main()
{
	struct Stu arr[3] = { {.id = 123456,.age = 18,.name = "zhangsan"},{123457,19,"lisi"},{123458,20,"wangwu"} };
	int num = sizeof(arr) / sizeof(arr[0]);
	int size = sizeof(arr[0]);
	qsort(arr, num, size, Cmp);
	for (int i = 0; i < 3; i++)
	{
		printf("%d,%d,%s\n", arr[i].id,arr[i].age,arr[i].name);
	}
	return 0;
}

底层原理就是比较首字母的ASCll的值谁大,谁大就排在后面第7讲:指针和结构体(一)(看这一篇知识点够了)_第15张图片

10 qsort函数的底层原理(用冒泡排序来解释)

10-1 比较整型:

模拟实现qsort函数排序
int cmp(void* p1,void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}
void Swap(void *p1,void*p2 ,int width)
{
	int i = 0;
	for (; i < width; i++)
	{
		char tmp = 0;
		 tmp = *((char*)p1 + i) ;
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = tmp;
	}

}
Bubble_sort(void* base, int num,int width,int (*cmp)(void*,void*))
{
	int i = 0;
	int j = 0;
	for (; i < num-1; i++)
	{
		for (j = 0; j  0)
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width,width);
			}
		}
	}
}

int main()
{
	int arr[10] = { 1,4,5,3,2,9,7,8,6,0 };
	int num = sizeof(arr) / sizeof(arr[0]);
	Bubble_sort(arr, num, sizeof(arr[0]), cmp);
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

10-2 比较结构体类型:

typedef struct Stu std;
struct Stu
{
	int id;
	int age;
	char name[20];
};
//按照字母首元素排序
void Swap(void* p1, void* p2, int size)
{
	int i = 0;
	for (; i < size; i++)
	{
		char tmp = *((char*)p1 + i);
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = tmp;
	}
}
int Cmp(void* p1, void* p2)
{
	return strcmp(((std*)p1)->name, ((std*)p2)->name);
}
void Bubble_name(void* base, int num, int size, int (*Com_name)(void*, void*))
{
	int i = 0;
	int j = 0;
	for (; i < 3; i++)
	{
		for (int j = 0; j < num - 1 - i; j++)
		{
			if (Com_name((char*) base + size*j, (char*)base + size * (j+1)) > 0)
			{
				Swap((char*)base + size * j, (char*)base + size * (j + 1),size);
			}

		}
	}
}

第7讲:指针和结构体(一)(看这一篇知识点够了)_第16张图片

你可能感兴趣的:(数据结构)