C语言指针进阶

1.字符指针

	char ch = 'w';
	char* pc = &ch;
	*pc = 'b';
	printf("%c\n", ch);
	 
	char* p = "abcdef";  //char装不下s，这是把字符串首字符地址给p
	//*p = 'w';   //由于上一句右边是常量字符串，在内存中是只读，会报错 因此上一句建议写成 const char* p = "abcdef";
	printf("%s\n", p);  //提供一个地址就能打印，到\0结束

2.指针数组

指针数组是数组

	int* arr[6];  //存放整型指针的数组
	char* arrr[6]; //存放字符指针的数组
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,2,3,4,5 };
	int arr3[] = { 1,2,3,4,5 };
	int* parr[3] = { arr1,arr2,arr3 };

3.数组指针

int* p1[10];  //p1是指针数组
int(*p2)[10];  //p2是数组指针，p2可以指向一个10个元素，每个元素int类型的数组

指向数组的指针
&数组名，取出的是整个数组的地址
&arr+1，不会访问arr[1]，而是访问arr后面的地址

	int arr[10] = { 1,2,3,4 };
	int* p = arr;
	int (*p2)[10] = &arr; //10不写会报错，且这个不是二级指针！！

	printf("%d\n", *(*p2+1));  // 2  //p2是指向数组的，*p2本质上是首元素的地址  //不推荐使用
	printf("%d\n", *p+1);  // 2 ！

//舒服使用数组指针
void print1(int arr[3][5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
void print2(int (*p)[5], int r, int c) //二维数组arr，&arr表示第一行的地址
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i) + j));
			printf("%d ",p[i][j]);//等价写法

		}
		printf("\n");

	}
}
int main()
{
	int arr[3][5] = { 1,2,33,24,12,1,13,1,1,1,13,1,2,3,4};
	print1(arr, 3, 5);
	print2(arr, 3, 5);
	return 0;
}

int(*parr[10])[5] = { &arr1,&arr2,&arr3 }; //parr存放数组指针的数组
//只初始化3个元素

4.数组参数、指针参数

一维数组传参

void test(int arr[])
{} 
void test(int arr[10])   //也可以
{}
void test(int* arr)
{}


void test2(int* arr[20])
{}
void test2(int** arr[20])
{}

int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);


	return 0;
}

二维数组传参

void test(int arr[3][5])
void test(int arr[][]) //不行，形参二维数组的行可以省略，列不能省略
void test(int arr[][5]) //可以
void test(int* arr)// 数组名表示第一行的地址，是一个一维数组的地址，不能放在一级指针
void test(int* arr[5])//指针数组肯定不对
void test(int(* arr)[5])// 可以
void test(int** arr)// 不行

int main()
{
	int arr[3][5] = { 0 };
	test(arr);


}

5.函数指针

函数名和&函数名都是函数的地址

int test(const char* str)
{
	printf("%s\n", str);
	return 0;
}
int main()
{
	int (*pf)(const char*) = test;
	(*pf)("abc");
	pf("abc");
	return 0;
}

	(*(void(*)())0)();  //是一次函数调用，调用0作为地址处的函数
	//1.把0强制类型转换为：无参，返回类型是void的函数的地址
	//2.调用0地址处的函数，不传参
	

void (*signal(int, void(*)(int)))(int);  
//signal函数的返回类型也是函数指针,该函数指针指向函数参数是int，返回类型是void
//以上代码是一次函数声明

优化上述代码后

typedef void(*pf_t)(int); //把void(*)(int)类型重命名为pf_t
pf_t signal(int, pf_t);

6.函数指针数组

函数指针数组：存放函数指针的数组

int add(const int x, const int y)
{
	return (x)+(y);
}
int sub(const int x, const int y)
{
	return (x)-(y);
}
int mul(const int x, const int y)
{
	return (x) * (y);
}
int Div(const int x, const int y)
{
	return (x) / (y);
}

int main()
{
	int(*pf)(int, int) = add;
	int (*arr[4])(int,int) = { add,sub,mul,Div };  //arr和方块先结合，说明是数组
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", arr[i](8, 4));
	}

	return 0;
}

7.指向函数指针数组的指针

int main()
{

	int (*pfarr[4])(int,int) = { add,sub,mul,Div }; 
	
	//指向函数指针数组的指针
	int (*(*ppfarr)[4])(int, int) = &pfarr;
	

}

8.回调函数

> //void* p = &a; 
> //没有具体类型的指针，可以接受任意类型的地址
>  //不能解引用，也不能+-整数
int cmpint(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2; //写成e2-e1就是降序
}
//void qsort(void* base, //要排序的数据的起始位置 
//	size_t num,       //待排序的数据元素的个数
//	size_t width,       //待排序元素大小（字节）
//	int(* cmp)(const void* e1, const void* e2)  //比较
//);  
//


void test1()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	
	qsort(arr, sz, sizeof(arr[0]), cmpint);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}


struct stu
{
	char name[20];
	int age;
};
int cmpstu_name(const void* e1, const void* e2)
{
	return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
}
void test2()
{
	//测试使用qsort排序结构体数据
	struct stu s[] = { {"zs",15},{"ls",33},{"af",23} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s,sz,sizeof(s[0]),cmpstu_name);
}
int main()
{
	test1();
	test2();
}

升级版冒泡

void Swap(char* buf1, char* buf2 , int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void bubblesort(void* base, int sz, int width, int(cmp)(const void* e1, const void* e2))
{

	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1; //有序
		int j = 0;;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width,width);
				flag = 0;
			}
		}
		if (flag == 1)
			break;
	}

}
void test3()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);

	bubblesort(arr, sz, sizeof(arr[0]), cmpint);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}