- 字符指针
- 数组指针
- 指针数组
- 数组传参和指针传参
- 函数指针
- 函数指针数组
- 指向函数指针数组的指针
- 回调函数
一：字符指针
指针类型中字符指针 char*
#include<stdio.h>
int main()
{
char* pa = "good bye";
//printf("%c\n",*pa);//本质是把字符串的首字符的地址存储在pa中
char* pa = "good bye";
char arr[] = "good bye";
printf("%s\n",pa);
printf("%s\n",arr);
return 0;
}
例题：
#include <stdio.h>
int main()
{
char str1[] = "game";
char str2[] = "game";
//两个不同数组，新创造的空间不同
const char* str3 = "computer";
const char* str4 = "computer";
//常量字符串是不能改的，只会存一份，所以两个指针变量都指向同一个地址
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;
}
//str1 and str2 are not same
//str3 and str4 are same
二：数组指针（指向数组的指针)
1.数组指针
#include<stdio.h>
int main()
{
int a = 10;
int* pa = &a;//整形指针
char b = 'q';
char* pb = &b;//字符指针
int arr[5] = {1,2,3,4,5};
int (*parr)[5] = &arr;//由于[]的优先级高于*，得带括号
}
从parr处开始,先与*结合,说明P 是一个指针 然后再与[]结合,说明指针所指向的内容是一个数组,然后再与int 结合,说明数组里的元素是整型的.所以parr 是一个指向由整型数据组成的数组的指针
（怎么判断呢？ 看变量先与谁结合）
2：&数组名和数组名
差分别为4 ，40。
&arr取的是整个数组的地址，而arr是数组首元素的地址
3：应用
//二维数组
#include<stdio.h>
void print1(int arr[3][5], int m, int n)
{
int i = 0;
int j = 0;
for (i = 0; i < m; i++)
{
int j = 0;
for (j = 0; j < n; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
//数组指针
void print2(int(*arr)[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");
}
}
int main()
{
int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
print1(arr, 3, 5);
print2(arr, 3, 5);
return 0;
}
//print1,2
//1 2 3 4 5
//2 3 4 5 6
//3 4 5 6 7
注意：
int(*parr[10])[5];
//首先parr[10]是个数组，去掉parr[10]后为指向的类型
//parr是以个存放数组指针的数组,能存放10个数组指针
//每个数组指针都能指向一个数组，数组有五个元素，均为int类型
三：指针数组（是一个存放指针的数组）
#include<stdio.h>
int main()
{
//指针数组-数组中存放指针（地址）
int a = 10;
int b = 20;
int c = 30;
int d = 40;
int* arr[5] = {&a,&b,&c,&d};
int i = 0;
for (i=0;i<4;i++)
{
printf(" %d\n ", *(arr[i]));
}
}
#include<stdio.h>
int main()
{
int a1[] = { 1,2,3,4,5 };
int a2[] = { 2,3,4,5,6 };
int a3[] = { 3,4,5,6,7 };
int* arr[3] = { a1,a2,a3 };//代表各数组首元素的地址
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;
}
//1 2 3 4 5
//2 3 4 5 6
//3 4 5 6 7
四：数组传参和指针传参
1：一维数组传参
#include <stdio.h>
void test1(int arr[10])//可以
{}
void test1(int arr[])//可以，元素个数可以省略
{}
void test1(int* arr)//可以，指针
{}
void test2(int* arr[20])//可以，存放int* 的整型指针数组
{}
void test2(int** arr)//可以，二级指针
{}
int main()
{
int arr1[10] = {0};
int* arr2[10] = {0};//存放int*的数组
test1(arr1);
test2(arr2); //指向int* 的首元素地址
}
2：二维数组传参
实参 只用填数组名 就行
形参可以为 二维数组 或 指针
//二维数组
void test(int arr[3][5])//可以
{}
void test(int arr[][])//错误。行可省略，列是不能省的
{}
void test(int arr[][5])//可以
{}
//指针
void test(int* arr)//不行。接收第一行的地址，第一行是5个整形的数组，不能用指针接收
{}
void test(int* arr[5])//不行。这是指针数组，得要整型数组指针才行
{}
void test(int(*arr)[5])//可以。为整型数组指针
{}
void test(int** arr)//不行。
{}
int main()
{
int arr[3][5] = { 0 };
test(arr);
return 0;
}
3：一级指针传参
#include <stdio.h>
void print(int* pstr, int sz) //用一级指针接收
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(pstr + i));
}
}
void test(char* p)
{
}
int main()
{
int arr[7] = { 2,0,2,2,10,0,2 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
print(p, sz);//p是一级指针
char ch = 'a';
test(&ch);//char*类
//char* p1 = &ch;
//test(p1);
return 0;
}
4：二级指针传参
#include <stdio.h>
void test(int** pstr) //二级指针接收
{
printf("num = %d\n", **pstr);//a的值
}
int main()
{
int a = 10;
int* pa = &a;//pa是一级指针
int** ppa = &pa;//ppa是二级指针
test(ppa);//二级指针传参
test(&pa);取一级指针的地址就是二级指针
int* arr[10] = {0};
test(arr);//也可以，传存放一级指针的数组
//，传的是整形指针数组的首元素的地址，而首元素为int*类型，结果为二级指针传参
return 0;
}
五：函数指针（存放函数地址的指针）
&函数名——取出函数的地址
注意：数组名 ！= &数组名
函数名 == &函数名
int (*pf)(int,int) = &Add;
#include<stdio.h>
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 ret = (*pf)(7,5);//通过函数指针调用函数.1
//int ret = pf(7,5);//2
//int ret = Add(7,5);//3
//1,2,3都一样。*的作用不大，可有可无，但只能在函数指针中这样
//int ret = *pf(7,5);//这样是不行的，等于对函数的结果12进行解引用。若加*得括起来
printf("%d\n",ret);//12
return 0;
}
例子：
#include<stdio.h>
void test(char* str)
{
}
int main()
{
void (*pt)(char*) = &test;//与函数要对应
return 0;
}
六：函数指针数组（存放函数指针的数组）
它可以存放多个参数相同,返回类型相同 的函数地址
int (*arr[3])(int, int) = { Add,Sub,Mul};
#include<stdio.h>
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 main()
{
//parr就是 函数指针数组
int (*parr[3])(int, int) = { Add,Sub，Mul};
return 0;
}
写一个计算器（加，减，乘，除）：
（函数指针数组的用途：转移表）
#include<stdio.h>
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 main()
{
int input = 0;
do{
menu();//菜单
//pfArr是函数指针数组
//转移表
int (*pfArr[5])(int, int) = { NULL, Add, Sub, Mul, Div };//
int x = 0;
int y = 0;
int ret = 0;
printf("请选择：>");
scanf("%d",&input);
if(input>=1 && input<=4)
{
printf("请输入2个数:>");
scanf("%d %d", &x, &y);
ret = (*pfArr[input])(x, y);
printf("%d\n",ret);
}
else if(input == 0)
{
printf("退出程序\n");
}
else
{
printf("选错了，重新选择");
}
}while(input);
return 0;
}
,
七：指向函数指针数组的指针
int(*p)(int,int);//函数指针
int(* p2[4])(int,int);//函数指针的数组
int(*(*p3)[4])(int,int);//取出函数指针数组的地址
//p3是一个指向函数指针数组的指针
补充：int arr[5];
数组元素类型：去掉数组名和元素个数 ， 剩下的就是——>int
数组类型 ：仅去掉数组名 ——>int[5]
八：回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针作为参数传给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
回调函数应用例子：
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 Cald(int (*pf)(int, int))
{
int x = 0;
int y = 0;
printf("请输入2个值：>");
scanf("%d %d", &a, &b);
return pf(x,y);
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
switch (input)
{
case 1:
ret = Cald(Add);//把Add函数指针传过去
//Add函数并不是直接调用的，而是通过函数指针调用的
printf("%d\n", ret);
break;
case 2:
ret = Cald(Sub);//把Sub函数指针传过去
printf("%d\n", ret);
break;
case 3:
ret = Cald(Mul);//把Mul函数指针传过去
printf("%d\n", ret);
break;
case 4:
ret = Cald(Div);//把Div函数指针传过去
printf("%d\n", ret);
break;
case 0:
printf("退出程序\n");
break;
default:
printf("选错了，重新选择\n");
break;
}
} while (input);
}
qsort 库函数（进行快速排序的实现）
(得引用头文件 stdlib.h )
void qsort (void* base,//void*能接收任意类型的地址，应用更加广泛;base中存放的是 待排序的数据里的第一个对象的地址
size_t num,//元素个数
size_t size,//一个元素占几个字节
int (*compar)(const void*,const void*)//用来比较待排序数据中的2个元素的函数
);
//
注意：int compareMyType (const void * a, const void * b)
{
if ( *(MyType*)a < *(MyType*)b ) return -1;
if ( *(MyType*)a == *(MyType*)b ) return 0;
if ( *(MyType*)a > *(MyType*)b ) return 1;
}
例子：用qsort函数进行排序
#include<stdio.h>
#include<stdlib.h>
int compar(const void* d1, const void* d2)
{
return *(int*)d1 - *(int*)d2 ;
}
void print_arr(int arr[],int sz)
{
int i = 0;
for(i=0;i<sz;i++)
{
printf("%d\n",arr[i]);
}
printf("\n");
}
int main()
{
int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr)/sizeof(arr[0]);
qsort(arr,sz, sizeof(arr[0]), compar);//排序
print_arr(arr, sz);
return 0;
}
以后继续补充qsort函数内容