二维数组指针，指针数组，指针函数

指针 操作 二维字符型数组 

1、 首先理解二维数组指针

       int a[3][4];               

       第一步，确定基类型：上面的数组从本质上讲，是一维数组的数组，写成int[4] a[3]可以更好的理解，a[3]是一个一维数组，其数组中的元素是一个由4个int类型数据组成的一维数组，定义一个，所以其基类型为int[4]。

       第二步，取地址&a[0]：由基类型 * 指针变量名可以得到如果要定义一个指针指向它，这个指针就是int[4] * p，但是C语言不支持这种写法，所以写成int (*p)[4]。

int (*p)[4] = a;

2.理解二维数组指针中的p和*p

int a[4][4] = {1,4,5,6,2,7,8,13,14,3,9,11,10,15,16,12};
int (*p)[4] = a;

printf("p = %p\n",p);// a[0]的地址，代表a这一行
printf("p + 1 = %p\n",p+1);//a[0]的下一个地址，a[1]的地址，代表这 a[1]一行。
printf("(p+1)+1 = %p\n",(p+1)+1);//a[2]这一行的地址
printf("*(p+1) = %p\n",*(p+1));//a[1][0]的地址
printf("*(p+1)+1 = %p\n",*(p+1)+1);//a[1][1]的地址

二维数组a的指针p，p与*p的意义并不一样。p与*p都是地址，p指向一行的地址，p+1指向下一行；*p代表数组一个元素的地址，*（p+1）则指向下一个元素。如果要取地址指向空间的数据内容，需要**p，*p指向一个元素，**p访问地址数据内容。

3.定义二维字符数组

char s[ ][10] = {"hello","world","china"};
char (*p)[10] = s; //p指向二维数组s 

二维字符型数组与整型不同，二维字符型数组用来处理字符串，指针p指向s，p表示s的地址，p等价于s[0]的地址，代表s[0]这一行的字符串的地址，p+1等价于下一行字符串的地址，*p则代表s[0]中存放的字符串。

练习:
    输入三个字符串 ，排序输出 

#include <stdio.h>
#include <string.h>

void putStr(char (*p)[20],int row)
{
	int i = 0;
	for (i = 0; i < 3; ++i)
	{
		printf("%s \n",*(p+i));
	}
}

void choiceSort(char (*p)[20],int row)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row-1; ++i)
	{
		for (j = i+1; j < row; ++j)
		{
			if (strcmp(*(p+i),*(p+j)) > 0)
			{
				char t[20];
				strcpy(t,*(p+i));
				strcpy(*(p+i),*(p+j));
				strcpy(*(p+j),t);
			}
			
		}
	}
}
	

int main(void)
{
    char s[][20] = {"hello","world","china"};
	
	putStr(s,3);
	choiceSort(s,3);
	puts("------------------\n");
	putStr(s,3);

	return 0;
}

指针的数组

1.先看以下3个初始化

char *p1 = "hello";
char *p2 = "world";
char *p3 = "china";

p1,p2,p3分别指向字符串常量区中“hello”，“world”，“china”不能被修改，

我们可以将上面3个写在一起组成一个指针数组：

char* pstr[3]= {"hello","world","china"};   数组中存放是 各个字符串的地址

2.函数中使用指针数组，形参形式为(char **p)

char **p：数组指针的指针，基类型是char*

3.练习:
    逆序，冒泡排序

#include <stdio.h>
#include <string.h>

void printStr(char * *p,int len)
{
	int i = 0;
	for (i = 0; i < 3; ++i)
	{
		printf("%s\n",*(p+i));
	}

}

void reverseStr(char **begin, char **end)
{
	while (begin < end)
	{
		char *t = *begin;
		*begin = *end;
		*end = t;

		begin++;
		end--;
	}
}

void bubbleSort(char **p,int len)         //冒泡排序
{
	int i = 0;
	int j = 0;

	for (i = len-1; i > 0; --i)
	{
		for (j = 0; j < i; ++j)
		{
			if (strcmp(*(p+j),*(p+j+1)) > 0)
			{
				char *t = *(p+j);
				*(p+j) = *(p+j+1);            //值不能被改变，交换地址
				*(p+j+1) = t ;
			}
		}
	}
}


int main(void)
{
	const char *p[] = {"hello","world","china"};
	printStr(p,3);
	reverseStr(p,p+2);
	bubbleSort(p,3);
	puts("---------------");
	printStr(p,3);
	return 0;
}

 指针 + 函数

1.通过指针 的方式 来调用函数

函数名 --- 代表函数的入口地址

int add(int a,int b) // 函数  
                     // 函数名 - 代表函数的入口地址 
                     // 函数名对应的数据类型：int (int a,int b)

  int (int a,int b)      // 代表一类函数
                             // 返回值为int型
                            // 带有两个int型的形参变量

 函数的指针应该写成 int(*p)(int,int)  这样的形式

 函数的调用：p(a,b);

说明:
 1.可以定义一个函数类型的指针变量 
   来保存函数的入口地址 
 2.有了这个指针变量 
   通过指针变量 进行函数调用 

#include <stdio.h>

int add(int a,int b)
{
	return a + b;
}
int main(void)
{
   int (*p) (int,int) = add;          //理解：int(int,int) *p
   int ret = p(1,2);
   printf("ret = %d\n",ret);

}

2.函数回调

回调函数 --- 通过函数指针调用函数 就是回调 
c语言中，使用了 函数指针 实现回调

练习:
    写一个程序 实现加，减，乘，除
    以回调函数的形式，打印对应的结果 
 

#include<stdio.h>
void proscessDate(int a,int b,int(pfunc)(int,int))
{
	int n;
	n=pfunc(a,b);
	printf("%d\n",n);
}

int add(int a,int b)
{
	return a+b;
}
int Chu(int a,int b)
{
	return a/b;
}

int Jian(int a,int b)
{
	return a-b;
}
int Cheng(int a,int b)
{
	return a*b;
}

int main(void)
{
	int a,b;
	scanf("%d%d",&a,&b);
	proscessDate(a,b,Cheng);
}

main函数

运行结果：