C语言 指针你都掌握了吗

C语言 指针你都掌握了吗

摘要

• 为什么需要用指针?

• 一些概念

  • 数组指针
  • 指针数组
  • 指针数组和数组指针在内存中的关系
  • 函数指针
  • 函数指针例子

• 指针作为参数的传递

• 通过函数修改指针

• 指针与结构体

• const关键字对指针的限制

• 空指针

• 上文答案

指针对于C来说太重要了，指针往往是复杂程序的基础，要掌握指针，不仅要熟悉语法，还需要对硬件和系统有所了解。

为什么需要用指针?

1. 指针是构建复杂数据结构的基础，指针的操作让数据变得很灵活
2. 通过指针可以用很小的代价实现复杂对象，复杂结构体的传递。提高程序的效率
3. 通过指针，在不同的区域，也能实现数据的共享。

我们来看下面几个概念

声明一个数组指针

int (*p_i)[10];//声明一个有10个元素的整型数组，p_i指向该数组

声明一个指针数组

int *p_i2[10];	//声明一个含有10个整型指针的数组

指针数组和数组指针在内存中的关系

声明一个函数指针

void fun1(char *str)		//定义一个函数
{
	printf("%s\n",str);
}

void(*pfun)(char *str) = &fun1;	//声明一个函数指针，指向函数fun1

函数指针的使用

(*pfun)("fun1");	//调用函数指针

----out----
fun1
    

函数指针看起来很简单，很好理解，那我们再看下面几个例子，体会他们的区别

char* (*fun1)(char * str);	//A
char** fun2(char * str); 	//B
char* fun3(char * str);		//C

//A 一个函数指针，返回值是char*型
//B 一个函数，返回值是char**型（指针的指针）
//C 一个函数，返回值char*

再往下看，声明一个函数指针数组

void (*pfun[3])();   //声明一个函数指针数组   

//赋值
pfun[0] = &fun1;

//调用
(*pfun[0])();

如果上面的例子很简单，我们再往下看

void fun1()		//定义一个函数
{
    printf("fun1\n");
}
  
int main()
{
	void (*p_fun)() = NULL;	//声明一个函数指针
	*(int*)&p_fun = (int)fun1;	//一个复杂的表达式
	(*p_fun)();
    return 0;
}

----out----
fun1

我们看到一个很复杂的表达式* (*int)&p_fun = (int)fun1;

*(int*)&p_fun = (int)fun1;

(int)fun1;
/*
将fun1强制转换为一个int型的整数,
int恰巧与一个指针的大小相等,
在32位平台上为4字节
*/   

&p_fun;			//取p_fun的地址

(int*)&p_fun;	//把p_fun的地址强制转换为int*型

*(int*)&p_fun;	//解引用，在p_fun的地址上储存int型的fun1值
    
//所以，实际上这句代码和这个等效
p_fun = fun1;

在内存中的运行状况：

还有一个例子，《C Traps and Pitfalls》这本经典的书中的一个例子，我们接着看

(*(void(*)())0)();
/*
1.void(*)()	是一个函数指针类型
2.(void(*)())0	把地址0强制转化为函数指针类型，也就是有一个函数的首地址是0
3.(*(void(*)())0)()	调用这个首地址为0的函数
*/

可以自我测试一下，解读下面的代码

(*(char**(*)(char **,char **) )0)(char **,char **);

指针作为参数的传递

传递一维数组

//声明

void change(int *nums);
void change(int nums[]);//编译器仍然将其看成指针
//调用
int nums[5];
change(nums);

传递二维数组

//声明
void change(int (*nums)[4]);
void change(int nums[][4]);

//调用
int nums[5][4];
change(nums);

指针传递字符串

//声明
void change(char *str);
//调用
char *p_name = "hello world";
change(p_name);

通过函数修改指针

当我们需要通过函数修改指针时，可以使用这两种办法
1.借助返回值

char *change(char* str)
{
    str = NULL;
    return str;
}
char *name="hello world";
name = change(name);
printf("%p",name);
----out----
00000000

2.使用指针的指针

//
void change(char** str)
{
    *str = NULL;
    return;
}
char *name="hello world";
change(&name);
printf("%p",name);
----out----
00000000

指针与结构体

结构体的指针声明

struct student{
    int age;
    char name[20];
} student1;

struct student*p_student = &student1;	//先声明结构体，再声明指针，指向结构体
struct student*p_student2 = (struct student*)malloc(sizeof(struct student));	//声明指针，再申请空间

//注意，malloc返回的是无类型的指针，所以需要使用类型强制转换

结构体指针的使用

//结构体，和结构体指针在访问成员变量时，稍有不同
p_student->age;
student1.age;

关于const对于指针的限制问题

情况1：

int num1 = 1,num2 = 2;
const int *p = &num1;
p = &num2;		//允许修改
*p = 4;			//修改错误

情况2：

int num1 = 1,num2 = 2;
int * const p = &num1;
p = &num2;		//修改错误
*p = 4;			//允许修改

情况3：

int num1 = 1,num2 = 2;
const int * const p = &num1;
p = &num2;		//修改错误
*p = 4;			//修改错误

总结一个规律，const只限定它右边的值，如const右边只有p，那么，p不允许修改，*p可以修改。

空指针

空指针指的是一个特殊的指针值，他与任何一个对象或者函数的地址不相符，但是和未初始化的指针又不相同。未初始化的指针可能指向任何地方。当malloc失败时，会返回空指针。

int *p;			//可能指向任何地方
int *a = NULL;	//空指针
int *b = 0;		//空指针
char *str = "hello world!";	//非空指针

上文答案

(*(char**(*)(char **,char **) )0)(char **,char **);
/*
1.char**(*)(char **,char **);		//一个函数指针类型
2.(char**(*)(char **,char **) )0;	//把地址0强制转换为函数指针类型，也就是有一个函数的首地址是0，
3.*(char**(*)(char **,char **) )0;//从函数首地址0提取出函数具体内容
4.(*(char**(*)(char **,char **) )0)(char **,char **);//调用函数
*/