计算机的硬件——CPU——支持32位虚拟地址空间和
64位虚拟地址空间
32位虚拟地址空间—CPU产生32bit位虚拟地址
64位虚拟地址空间—CPU产生64bit位虚拟地址
虚拟地址——编译器中打印的地址——在实际访问空间时需要转换成物理地址才能访问到内存空间
物理地址——访问内存空间的地址
cpu通过地址线进行传递，产生虚拟地址，虚拟地址通过硬件和软件的转换，变成物理地址，访问内存空间
字符指针：
一般使用：int main()
{
char ch='w';
char* pc=&ch;
return 0;
}
其他使用：
int main()
{
char* p="abcdef";
//"abcdef"是一个常量字符串，常量字符串不可更改 //p中存入的是a的地址
printf("%c ",*p);
//打印出a
}
//"abcdef"储存在内存中的只读数据区
错误示例：
int main()
{
char* p="abcdef";
*p='w'; //发生段错误
printf("%s",p);//在vs2013一般状态下，不会报错，但实际是会系统崩溃的
}
int main()
{
char arr1[]="abcdef"; 由char加数组定义的字符串为变量
char arr2[]="abcdef"; 由char*+指针变量名指向的字符串（直接打出来，不是数组中的字符串）为常量字符串
char* p="abcdef";
char* q="abcdef";
if(arr1==arr2)
//数组名数值上表现为地址
printf("hehe");
else
//打印haha
printf("haha");
if(p==q)
//"abcdef"为常量字符串,指针所指向的为同一空间
printf("hehe");
//指针指向的，为独立于数组arr1，arr2空间的另一块空间
else
//打印hehe
printf("haha");
//"abcdef"为常量字符串//常量字符串不可更改，只需要储存一份，所以两个指针指向的是同一空间
}
int a,b;
//a,b都是int类型
int* a,b;
//a是int*类型，b是int类型
int* a,*b;
//这样定义才能使ab都为指针类型
若typedef int* pint
//typedef是类型重命名，pint是一个新的类型
pint pa,pb;
//pa，pb类型都为int*
若#define pint int*
/
/#define是替换，相当于把int*替换换
成pint
pint pa,pb;
//int* pa,pb;
//pa是int*类型，pb是int类型
指针数组
指针数组是一个存放指针的数组
示例：int* parr[5];//存放5个整形指针的数组——指针数组——每个元素类型是int*
char* carr[10];//存放10个字符指针的数组——指针数组——每个元素类型是char*
char ** arr[5];//存放5个二级字符指针的数组——指针数组——每个元素类型是char*
*
（初始化大括号赋0即可（{0}），数字0在指针中可以被认为是NULL）
使用示例：
例1
int main()
{
int i;
int a[5] = { 1,2,3,4,5 };
int b[5] = { 3,4,5,6,7 };
int c[5] = { 4,6,8,9,10 };
int* p[3] = { a,b,c };
for (i = 0; i <= 2; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf("%d", *(p[i] + j));
}
printf("\n")；
}
return 0;
}
例2
int main()
{
const char* arr[] = { "abcdef","qwer","xyz" };
//将"abcdef","qwer","xyz"的首地址分别存储到数组arr的空间中
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for(i = 0; i < sz; i++)
{
printf("%s",arr[i]);
}
return 0;
}
例3
int main()
{
int arr1[] = {1,2,3,4,5};
int arr2[] = {2,3,4,5,6};
int arr3[] = {3,4,5,6,7};
int *arr[] = {arr1,arr2,arr3};
//数组arr中存放arr1,arr2,arr3的首地址
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for(i = 0; i < sz; i++)
{
int j = 0;
for(j = 0; j < 5; 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
数组指针——疑难
数组指针是一种指针，指针指向数组，存放数组的地址
示例：
int main()
{
int arr[10]={1,2,3,4,5,6,7,8,9,10};
int (*p)[10]=&arr;
//不加括号，[]的优先级比*高，p[]是一个数组，加上括号*p是指针
//&是取地址，p解引用后是拿到arr
return 0;
}
int main()
{
char* arr[5];
char* (*p)[5]=&arr;
//*p说明是一个指针，5是指指向的数组有5个元素，char*指针指向的元素类型
return 0;
}
数组名是数组首地址，&数组名是数组地址
数组名+1和&数组名+1的效果不一样，数组名的类型是char*，&数组名的类型是char*(*)[5]
数组名和&数组名的值是一样的
数组指针使用示例：
int main()
{
int a[10]={1,2,3,4,5,6,7,8,9,10};
int (*p)[10]=&a;
int i;
for(i=0;i<10;i++)
{
printf("%d",(*p)[i]);
//*((*p)+i)//解引用p相当于拿到数组名
//这样使用效率低，所以一般用于二维数组
}
}
数组指针实际应用于二维以上的数组
void print1(int a[3][5], int x, int y)
//参数是数组形式，二维数组传参，二维数组接收
{
int i;
for (i = 0; i <x; i++)
{
int j = 0;
for (j = 0; j < y; j++)
{
printf("%d\t", a[i][j]);
}
printf("\n");
}
}
void print2(int (*p)[5],int x,int y)
//参数是指针形式，二维数组首元素相当于a[0]一维数组
{
int i;
for (i = 0; i < x; i++)
{
int j = 0;
for (j = 0; j < y; j++)
{
printf("%d\t", *(*(p+i)+j));//*(p[i]+j) //(*(p+i))[j]
//*(p+i)相当于拿到第i行第1个元素的首地址
}
printf("\n");
}
}
int main()
{
int a[3][5] = { { 1,2,3,4,5 } ,{ 3,4,5,6,7 } ,{ 4,6,8,9,10 } };
print1(a, 3, 5);
print2(a, 3, 5);
//将二维数组化为一维数组，首元素为{1,2,3,4,5}
return 0;
}
int arr[5]
//arr是一个有五个元素的整形数组
int *parr1[10]
//parr1是一个数组，数组有10个元素，每个元素的类型是int*，parr1是一个指针数组
int (*parr2)[10]
//parr2是一个指针，该指针指向一个数组，数组有十个元素，每个元素类型是int，parr2是数组指针
int (*parr3[10])[5]
//parr3是一个数组，该数组有10个元素，每个元素是一个数组指针，该指针指向的数组有5个元素，
每个元素类型是int，
parr3[10]明确了数组名和元素个数，剩下的是元素类型int(* )[5]，为数组指针.
//对数组指针解引用相当于拿到数组名
//去掉变量名，剩下的就是类型
//示例int (*parr2)[10]去掉变量名parr3剩下的int (*)[10]为类型
数组传参，指针参数
写代码时，需要把数组和指针传给函数
void test(int* arr[])
//或void test(int** arr);//数组传给同类型数组，数组首元素是指针，指针的地址用二级指针储存
……
int* arr[20]={0};
//arr是数组，传参传数组首地址。
test(arr);
……
当形参是指针时，实参可以是指针，也可以是类型变量的地址
一维数组传参：
#include<stdio.h>
void test( int arr[] )
//ok
{}
void test( int arr[10] )
//ok
{}
void test( int* arr )
//ok
{}
void test2( int* arr[20] )
//ok
{}
void test2( int** arr )
//ok
{}
int main()
{
int arr[10] = {0};
int* arr2[20] = {0};
test(arr);
test2(arr2);
//arr2是指针数组，每个元素类型是int*，一级指针数组的首地址是一个二级指针
//一级指针做作实参时，形参不能为二级指针，形参若为二级指针，实参要&一级指针
return 0;
}
二维数组的传参，行可以省略，列不可省略，同样传数组首地址(二维数组首元素为第一行，首元素的地址为第一行的地址)。
二维数组在内存中存储的方式同一维数组：开辟行标乘列标个数的连续类型（int char ……）空间
二维数组传参不能使用指针int* p接收，二维数组首元素的地址是第一行的地址，类型为数组指针，不能使用整形指针接收
一级指针可以存放在一级指针中，一级指针的地址存放在二级指针中。
void test( int arr[3][5] )
//ok
{}
void test( int arr[ ][ ] )
//no
{}
void test( int arr[0][5] )
//ok
{}
//二维数组传参列不能省略，因为要确认arr+1要跳过多大的空间
//
列的作用，决定数组在进入下一行时，跳过的字节数为：列下标*类型字节。
//
示例int [][4]跳到下一行跳过字节数为：4*sizeof（int）=16；char [][3]跳到下一行，跳过的字节数为3*sizeof（char）=3.
void test2( int* arr )
//no
{}
void test2( int* arr[5] )
//no
{}
void test( int (*arr)[5] )
//ok
{}
void test( int** arr )
//no
{}
int main()
{
int arr[3][5] = {0};
test(arr);
return 0;
}
//对数组指针解引用相当于拿到数组名
函数指针——指向函数的指针
int add(int x , int y)
{
return x + y;
}
int main()
{
printf("%p\n", &add);
printf("%p\n", add);
//两者打印的值相等
//不同于数组，&数组名与数组名不等价，函数没有首元素，&函数名与函数名是等价的
return 0;
}
如果想要将函数地址存起来，则需要函数指针，定义方式与其他指针不同
首先定义函数名：pf，类型为指针：*pf，指向的函数参数类型为int，int：*pf(int , int)，防止先与参数类型结合将指针框起来：(*pf)(int , int)，指针指向函数返回值为int：int (*pf)(int , int)。所以该指针指向一个参数类型为(int，int)，返回值为int的函数
该指针变量的变量名为pf，类型名为int (*)(int , int)。
指针调用：
int (*pf)(int , int) = &add;
//int (*pf)(int , int) = add;
int sum = (*pf)(2,3);
//对指针解引用找到对应函数，用函数调用操作符()对函数传参
使用函数时函数名+函数调用操作符即可，现在已知函数名就是函数地址，当把函数地址赋给指针后，直接使用指针进行调用，不进行解引用的效果会不会和函数一样？
答案是肯定的，int sum = pf(2,3);的结果和int sum = (*pf)(2,3);一样
变态代码其一：(*( void ( * ) ( ))0) ( );
想要理解含义需要清楚每个括号的含义，由上文得知，函数指针的定义方式和其他指针不同，是由返回值类型+( * )+( 参数类型 )构成的。由此可知void ( * ) ( )是一个函数类型指针，剩下的(*( 类型 )0)( )就很方便理解了。将0强制类型转换为函数指针类型，再解引用，最左边的( )是函数调用操作符。因为强制类型转换时参数类型为空【(*( void ( * )
( ))0) ( );】，所以使用函数调用操作符时参数类型也为空【(*( void ( * ) ( ))0)
( );】。这是一次函数调用，调用0地址处的函数。
这段程序只是解析是什么意思。在指针中0可以被视为NULL，用户程序是不能直接访问0地址处的
变态代码其二：void( *signal ( int, *void ( * ) ( int ) ) ) ( int );
同样void ( * ) ( int )为函数指针类型，剩下部分为【void( *signal ( int, *(指针类型) ) ) ( int );】。signal是和后面的()结合，所以signal不是指针。而signal调用没有变量名，所以signal是一个函数声明，函数名，参数类型都有了，还缺返回类型。将已知的去掉得到【void( * ) ( int );】。这就是返回类型了。返回类型是一个函数指针。所以signal是一个函数声明。(int)是否可以移动到左边？不可以，*要始终和函数名结合。至于为什么要和函数名结合，我也不知道，就当语法规则吧
将函数声明简化：typedef void (* ) ( int ) pfun_t;(错误)，typedef void (*pfun_t ) ( int );(正确)
化简后：pfun_t signal ( int, pfun_t );
void (*p) ( int ) //p是指针变量名
typedef void (*pf ) ( int ); //pf是类型名
对数组的重定义：typedef int T[10]，是对int [10]类型的重定义，T a[20]等价于a[20][10]。
函数指针数组——储存函数指针的数组——也叫转移表
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;
}
int main()
{
int (*pf1)( int , int ) = add;
int (*pf2)( int , int ) = sub;
int (*pf3)( int , int ) = mul;
int (*pf4)( int , int ) = div;
return 0;
}
当参数类型相同，返回值类型相同时，可以定义函数指针数组存储4个函数地址
函数指针数组使用示例：
int (*pfarr[4])( int , int ) = {add , sub , mul , div};
//初始化
int i = 0;
for(i = 0 ; i < 4 ; i++)
{
int ret = pfarr[i](8,4);
printf("%d\n",ret);
}
应用示例：
#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;
int x = 0;
int y = 0;
int ret = 0;
int (*pfarr[5])(int, int) = { 0,add,sub,mul,div };
do
{
menu();
scanf("%d", &input);
if (input == 0)
{
printf("退出计算器\n");
break;
}
else if (input >= 1 && input <= 4)
{
printf("输入两个数\n");
scanf("%d%d", &x, &y);
ret = pfarr[input](x, y);
printf("%d\n", ret);
}
else
{
printf("选择错误\n");
}
} while (input);
return 0;
}
不使用函数指针数组的话就只能用switch一个一个判断，这样case:部分的代码会大量重复，而且使用函数指针数组后，添加其他功能只需要补充函数块，菜单，和函数指针数组里的内容就可以了
指向函数指针数组的指针——指向函数指针数组的指针
int add(int x, int y)
{
return 0;
}
int main()
{
int (*p)( int , int ) = add;
//函数指针
int (* pf[4])( int , int );
//函数指针数组
int (* (*ppf)[4])( int , int ) = &pf;
//ppf是一个指针，该指针指向一个存放函数指针的数组
//指向函数指针数组的指针在书写时，从对应函数指针数组中复制框架，然后在使其变为指针
}
函数指针的应用
#include<stdio.h>
void menu()
{
printf("***********************************\n");
printf("********* 1.add 2.sub **********\n");
printf("********* 3.mul 4.div **********\n");
printf("********* 0.exit **********\n");
printf("***********************************\n");
}
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 calc(int (*pf)(int , int))
//通过函数指针来接收函数地址
{
int x = 0;
int y = 0;
int ret = 0;
printf("输入两个操作数\n");
scanf("%d%d", &x, &y);
ret = pf(x,y);
printf("ret = %d", sum);
}
int main()
{
int input = 0;
do
{
menu();
printf("请选择>:");
scanf("%d",&input);
switch(input)
{
case 1:
calc(add);
break;
case 2:
calc(sub);
break;
case 3:
calc(mul);
break;
case 4:
calc(div);
break;
}
} while (input);
return 0;
}
//利用函数指针将差异化的代码转换为一个代码
回调函数——即如函数指针应用部分所示
回调函数是通过函数指针调用的函数。如果你将函数的地址作为参数传递给另一个函数，当这个地址被用来调用其所指向的函数时，我们说这是回调函数。即将add的地址传给calc后，通过calc中的pf调用add函数时，被调用的add函数称为回调函数。回调函数不是由实现方直接调用，而是由特定的事件或条件发生时由另外一方调用的，用于对事件或条件进行响应。即add等函数没有直接调用，而是传递给calc，根据input的不同而做出不同的响应。
void bubble_sort(int *p,int sz)
{
int i = 0;
int j = 0;
for(i = 0; i < sz-1; i++)
{
for(j = 0; j < sz-i-1; j++)
{
if(p[j] > p[j+1])
{
int tmp = p[j+1];
p[j+1] = p[j];
p[j] = tmp;
}
}
}
}
void print_bubble(int *p,int sz)
{
int i = 0;
for(i = 0; i < sz; i++)
{
printf("%d ", p[i]);
}
}
int main()
{
int sz = 0;
int arr[10] = {2,5,8,3,6,9,0,1,4,7};
sz = sizeof(arr)/sizeof(arr[0]);
bubble_sort(arr,sz);
print_bubble(arr,sz);
return 0;
}
如上工程所示，这是一个简单的冒泡排序，但仅仅可以排序整型数组，想办法使其可以排序任意类型
通过C语言提供的库函数qsort来参考，qsort——通过快速排序的方法实现——快速排序和冒泡排序一样是一种排序算法
void qsort(void* base,
//指针//要排序数据的起始位置
size_t num
,
//size_t是unsigned int//数组元素个数
size_t width,
//一个元素所占字节大小
int (* compare)(const void* e1 , const void* e2)
//函数指针//在使用时传一个比较函数
);
compare函数必须满足以下条件：
e1>e2——返回大于0的数
e1=e2——返回0
e1<e2——返回小于0的数
qsort可以排序包含字符型，整型，字符串型，结构体型等类型的数据
比较函数中void*是无具体类型的指针，该指针具有如下特性：
1.可以存储任意类型地址
2.不可以直接进行解引用操作，需要进行强制类型转换后进行解引用操作
3.不能直接进行加减操作，需要进行强制类型转换后进行加减
int cmp_int (const void* e1 , const void* e2)
//比较e1，e2指向的数据
{
if( *(int*)e1 >
*(int*)e2
)
return 1;
else
if( *(int*)e1 <
*(int*)e2
)
return -1;
else
return 0;
}
//cmp_int满足compare函数的条件
//化简cmp_int: return
*(int*)e1 - *(int*)e2
int main()
{
int sz = 0;
int arr[10] = {2,5,8,3,6,9,0,1,4,7};
sz = sizeof(arr)/sizeof(arr[0]);
qsort(arr , sz , sizeof(arr[0]) , cmp_int);
//默认排序方式为升序，若想排降序，e1e2位置需要互换
//qsort可以完成数组内容所有元素的比较，并进行排序
return 0;
}
对结构体排序：
struct stu
{
char name[20];
int age ;
float sorce;
};
int cmp_struct_by_name(const void* e1 , const void* e2)
{
return strcmp(((struct stu*)e1)->name , ((struct stu*)e2)->name);
//strcmp的比较方式是比较首字符的ascall码值，相同就比较下一个字符，全部相同才返回0
}
int cmp_struct_by_age(const void* e1 , const void* e2)
{
return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
int cmp_struct_by_sorce(const void* e1 , const void* e2)
//只需要满足比较函数条件即可，实际的排序会在qsort中进行
{
if ( ((struct stu*)e1)->sorce > ((struct stu*)e2)->sorce )
//e1e2是结构体类型，需要排序的是结构体类型
return 1;
else if( ((struct stu*)e1)->sorce < ((struct stu*)e2)->sorce )
return -1;
else
return 0;
//浮点数相减返回整型会出问题
}
void print_stu(struct stu arr[] , int sz)
{
int i = 0;
for(i = 0 ; i < sz ; i++)
{
printf("%s %d %f\n" , arr[i].name , arr[i].age , arr[i].sorce);
}
printf("\n");
}
void test1()
{
struct stu arr[3] = {{"zhangsan" , 20 , 87.6f} , {"lisi" , 18 , 99.0f} , {"wangerma" , 16 , 60.0f}};
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr , sz , sizeof(arr[0]) , cmp_struct_by_sorce);
//按成绩排序
qsort(arr , sz , sizeof(arr[0]) , cmp_struct_by_age);
//按年龄排序
qsort(arr , sz , sizeof(arr[0]) , cmp_struct_by_name);
//按名字排序
print_stu(arr , sz);
}
int main()
{
test1();
return 0;
}
qsort模拟——使用冒泡排序的逻辑，快速排序的算法
int cmp_int (const void* e1 , const void* e2)
//比较e1，e2指向的数据
{
if( *(int*)e1 > *(int*)e2 )
return 1;
else if( *(int*)e1 < *(int*)e2 )
return -1;
else
return 0;
}
void swap(char* buf1 , char* buf2 , int width)
//因为不知道具体类型，只能通过char类型和width一字节一字节的交换
{
int i = 0;
for(i = 0; i < width; i++)
{
char tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
void bubble_sort(void* base , int sz , int width , int (*cmp)(const void* e1 , const void* e2))
//上方e1e2可以省略，cmp是函数指针，e1e2不是需要传参的变量
{
int i = 0;
int j = 0;
for(i = 0; i < sz-1; i++)
{
for(j = 0; j < sz-i-1; j++)
{
if( cmp((char*)base + j*width , (char*)base + (j + 1)*width) > 0 )
{
swap( (char*)base + j*width , (char*)base + (j + 1)*width , width);
//用char类型来计算具体类型的空间，因为char的空间最小，在通过width掌握交换的空间大小
}
}
}
}
void print_bubble(int *p,int sz)
{
int i = 0;
for(i = 0; i < sz; i++)
{
printf("%d ", p[i]);
}
}
void test1()
{
int sz = 0;
int arr[10] = {9,8,7,6,5,4,3,2,1,0};
sz = sizeof(arr)/sizeof(arr[0]);
bubble_sort(arr,sz,sizeof(arr[0],cmp_int));
//cmp_int是比较方式，若想比较更多类型，还需要写不同类型的比较函数，从这个角度来看，qsort不是完全的通用排序。
print_bubble(arr,sz);
//打印方式也并非固定
}
int main()
{
test1();
return 0;
}
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
