1.字符指针 

int main()
{
	//本质上是把"hello the"这个字符串的首字符地址存储在了ps中
	char* ps = "hello the";
	char arr[] = "hello the";
	
	printf("%c\n", *ps);//h
	
	printf("%s\n", ps);
	printf("%s\n", arr);
	return 0;
}

int main()
{
    char str1[] = "hello bit.";
    char str2[] = "hello bit.";
    const char* str3 = "hello bit.";
    const char* str4 = "hello bit.";
    if (str1 == str2)
        printf("str1 and str2 are same\n");
    else
        printf("str1 and str2 are not same\n");

    if (str3 == str4)
        printf("str3 and str4 are same\n");
    else
        printf("str3 and str4 are not same\n");

    return 0;
}

2.指针数组

int main()
{
	//指针数组
	//数组——数组中存放的是指针（地址）
	//int* arr[3];//存放整型指针的数组
	int a[] = { 1,2,3,4,5 };
	int b[] = { 2,3,4,5,6 };
	int c[] = { 3,4,5,6,7 };
	int* arr[3] = { a,b,c };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", *(arr[i]+j));
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

 3.数组指针

4. 数组参数、指针参数 

一定要分析清楚，实参传过去的是什么。是地址的话是谁的地址，而形参对应又应该用什么形式接收。

一维数组传参

二维数组传参 

一级指针传参

二级指针传参

void test(char **p)
{
 
}
int main()
{
 char c = 'b';
 char*pc = &c;
 char**ppc = &pc;
 char* arr[10];
 test(&pc);
 test(ppc);
 test(arr);//Ok?
 return 0;
}

5.函数指针 

//函数指针——存放函数地址的指针
//&函数名——取到的就是函数的地址
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	//&函数名等价于函数名
	printf("%p\n",&(Add));
	printf("%p\n",Add);

	//函数指针变量
	/*int(*pf)(int, int) = &Add;*/
	int(*pf)(int, int) = Add;//意味着Add===pf
	printf("%d\n", (*pf)(3, 5));
	printf("%d\n", pf(3, 5));
	printf("%d\n", Add(3, 5));
	return 0;
}

6.函数指针数组 

int (*pf)(int,int)=Add;
int (*pf1)(int,int)=Sub;
int (*pfArr[2])(int,int);//函数指针数组pfArr

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

//整型数组
int arr[5];
int (*p1)[5]=&arr;
//p1是指向(整型数组)的指针


//整型指针的数组
int* arr[5];
int* (*p2) [5]=&arr;
//p2是指向(整型指针数组)的指针

//函数指针
int (*p)(int,int);
//函数指针数组
int (*p2[4])(int,int);
p3=&p2;//取出的是函数指针数组的地址
//p3是一个指向(函数指针数组)的指针
int (*(*p3)[4])(int,int);

8.回调函数

实例1——计算器的实现 

//回调函数
int Add(int x, int y)
{
	return x + y;
}

int Sub(int x, int y)
{
	return x - y;
}

int Mul(int x, int y)
{
	return x * y;
}

int Div(int x, int y)
{
	return x / y;
}

void menu()
{
	printf("**************************\n");
	printf("**** 1. add    2. sub ****\n");
	printf("**** 3. mul    4. div ****\n");
	printf("****     0. exit      ****\n");
	printf("**************************\n");
}

int Calc(int (*pf)(int, int))
{
	int x = 0;
	int y = 0;
	printf("请输入2个操作数>:");
	scanf("%d %d", &x, &y);
	return pf(x, y);
}

int main()
{
	int input = 0;
	//计算器-计算整型变量的加、减、乘、除
	//a&b a^b a|b a>>b a<<b a>b

	do {
		menu();

		int ret = 0;
		printf("请选择:>");
		scanf("%d", &input);

		switch (input)
		{
		case 1:
			ret = Calc(Add);
			printf("ret = %d\n", ret);
			break;
		case 2:
			ret = Calc(Sub);
			printf("ret = %d\n", ret);
			break;
		case 3:
			ret = Calc(Mul);//
			printf("ret = %d\n", ret);
			break;
		case 4:
			ret = Calc(Div);//
			printf("ret = %d\n", ret);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误，重新选择!\n");
			break;
		}

	} while (input);
	return 0;
}

 实例2——qsort函数的学习和模拟实现

模拟实现 

//模仿qsort函数实现一个冒泡排序的通用算法
//不同类型数据比较方法交给使用者确定
void Swap(char* buf1, char* buf2,int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}


void bubble_sort(void* base, int num, int size,
	int(*cmp)(const void* e1, const void* e2))
{
	int i = 0;
	//躺数
	for (i = 0; i <num-1; i++)
	{
		//一趟的排序
		int j = 0;
		for (j = 0;j < num - 1 - i; j++)
		{
			//两个元素的比较
			if (cmp((char*)base+j*size,(char*)base+(j+1)*size) > 0)
			{
				//交换
				Swap((char*)base + j * size, (char*)base + (j + 1) * size,size);
			}
		}
	}
}

int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}

void test3()
{
	//整型数据的排序
	int arr[] = { 9,8,7,6,5,4,3,2,1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//排序
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	//打印
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}


int main()
{
	test3();
	return 0;
}

需要注意的点：