指针（3）

1，字符指针
2，数组指针
3，指针数组
4，数组传参和指针传参
5，函数指针
6，指向函数指针数组的指针
7，函数指针数组
8，回调函数
1，字符指针
以char* 为例

int main()
{   
     char b='c';
     char *p=&b;
     *p='c';
     return 0;
     }
 还有一种方法
 int main（）    
 {
    char *p="hello"
    printf("%s",p);
    return 0;
 }

注意当几个指针指向同一个字符串的时候，它们实际上会指向同一块内存，而用常量去初始化不同的数组，就会开辟出不同的内存。
2,数组指针（指向数组的指针）
以 int (*p)[]为例 类型为 int[]

 void print(int(*p)[][4],int row,int col)
 {
   int i=0;
   int j=0;
   for(i=0;i<row;i++)
   { 
       for(j=0;j<col;j++)
       {
          printf("%d",p[i][j]);
       }
       printf("\n");
   }
 }
 使用：int main（）
 {
   int （*p)[][4]={1,2,3,4,5,6};
   print(p,2,4);
   return 0;
 }

**注意：**一般写数组指针的时候不用int（*p)[]=&arr的方式写，而是用上面的方式写，而且&arr指向的是整个数组的地址，虽然说与arr所指的地址是一样的，但所代表的意义不同，后者是首元素的地址。以int 为例&arr+1与&arr相差4（sizeof(arr)/sizeof(arr[0])个字节，而arr+1与arr只差四个字节；

 3,指针数组（存放指针的数组）
 以int*p[]为例   类型为 int*
 int *p[3]={&a,&b,&c};   
 int arr1[3]={1,2,3};
 int arr2[3]={4,5,6};
 int arr3[3]={7,8,9};
 int *p[3]={arr1,arr2,arr3};
 int**p=p;   //p代表的是一级指针 

 int main()
{
	char *str1 = "hahah";
	char *str2 = "gegeg";
	char *str3 = "daada";
	char *arr2[] = { str1, str2, str3 };     //和下面的那种写法都是一样的
	char**arr3[3] = { &str1, &str2, &str3 };
	printf("%s\n", *(arr3[0]));
	printf("%s\n", *(arr2+1));
	system("pause");
	return 0;
}

4，数组传参，指针传参

void test(int*arr1)
void test(int arr1[])    //[]自带解引用的效果
void test2(**arr2)
void test2(*arr2[10])
int main()
{
  int arr1[10]={0};
  int *arr2[10]={0};
  test(arr1);
  test2(arr2);
}

5,函数指针（指向函数的指针）

int max(int b,int c)
{  
  return b>c?b;c;
}
int find(int(*p),int a)(int,int)
{ 
 int max=p(10,87);
 return a=a>max?a;b; 
}
int main()
{
  int b=10; int c=87;
  int a=find(max,100);
  printf("%d",a);
}

6,函数指针数组 (存放函数指针的数组）
以 int (*paa[10])() 用途：转移表
计算器的例子：

7，指向函数指针数组的指针
是一个指针，指针指向的是一个数组，数组里的元素是函数指针
定义

int main()
{  //函数指针*pat
  void (*pat)(const char*)=test;
  //函数指针数组 psea
  void (*psea[])(const char*);
  //指向函数指针数组的指针
  void(* (*psea[]))(const char*)=&psea
}

8,回调
把函数指针作为一个参数传给另一个函数，当这个指针被用来调用其所指函数时，就叫做回调函数，实在特定的事件发生时由另一方调用的。