普通指针、常指针、常量指针与函数指针

指针

普通指针：int *p0;
常量指针：const int *p1;或int const *p2;
常指针：int * const p3 = &b;、int const * const p4;
区别：

• 普通指针，只能指向变量，不能指向常变量，常变量可以定义常量指针来访问
• 常量指针，指针的值可以改变，不能够用这个指针修改指针指向的内存的值。指针可以指向常变量，也可以指向变量
• 常指针
  • 指向变量的常指针，指针变量的值不能被改变，可以通过这个常指针修改常指针指向的变量的值。只能指向变量，不能指向常变量。定义的时候要初始化，初始化过后就不能再修改，和static定义的变量的用法一样
  • 指向常变量的常指针，指针不能被修改，同时指针指向的内存也不能被修改。第一个const表明不能通过这个常指针修改常指针指向的变量的值，第二个const表明指针变量的值不能被修改

区分常量指针和常指针不能被修改的量的技巧：const后面的量不能被修改
例子：

#include <stdlib.h>
#include <stdio.h>

int main() {
	const int a = 20;  // 只读变量，常变量，值不能改变的变量 
	int b = 30;
	int x;
    int y;
	/*普通指针，只能指向变量，不能指向常变量，常变量可以定义常量指针来访问*/
	int *p0; 
	
	/*常量指针，指针的值可以改变，不能够用这个指针修改指针指向的内存的值。指针可以指向常变量，也可
	以指向变量*/
	const int *p1;
	
	/*常量指针，指针的值可以改变，不能够用这个指针修改指针指向的内存的值。指针可以指向常变量，也可
	以指向变量，和上面那种定义等效*/
    int const *p2;
    
    /*常指针，指针变量的值不能被改变，可以通过这个常指针修改常指针指向的变量的值。只能指向变
	量，不能指向常变量。定义的时候要初始化，初始化过后就不能再修改，和static定义的变量的用法一样*/
    int * const p3 = &b;
    //int * const p3 = &a;  // 报错，因为常指针不能指向常量 
    
    /*指向常变量的常指针，指针不能被修改，同时指针指向的内存也不能被修改。第一个const表明不能通
	过这个常指针修改常指针指向的变量的值，第二个const表明指针变量的值不能被修改*/
	int const * const p4 = &b; 
	/*区分常量指针和常指针不能被修改的量的技巧：const后面的量不能被修改*/ 
	
    p1 = &a;  // 指向常变量 
    x = *p1;  // 通过指针取出 a 的值
    p1 = &b;  // 指向变量
    y = *p1;  // 通过指针取出 b 的值
    //*p1 = 40;  // 会报错，不能够用这个指针修改指针指向的内存的值 
	printf("指向常量的p1值为：%d\n", *p1);
	printf("指向变量的p1值为：%d\n", *p1);

    //p3 = &a;  // 会报错，p3不能被赋值，只能通过初始化赋值 
    printf("修改前的b的值为：%d\n", b);  // 修改前的变量的值
    printf("修改前的p3的值为：%d\n", *p3);
	*p3 = 50;
    printf("修改后的b的值为：%d\n", b);  // 通过这个常指针修改常 b 的值
    printf("修改后的p3的值为：%d\n", *p3);
    
    //*p4 = 60;  // 报错，因为常变量不能被修改 
    printf("p4的值为：%d\n", *p4);
    
	system("pause");

	return 0;
}


运行结果：
指向常量的p1值为：30
指向变量的p1值为：30
修改前的b的值为：30
修改前的p3的值为：30
修改后的b的值为：50
修改后的p3的值为：50
p4的值为：50

函数指针

数指针的使用形式:

1. 直接使用函薮指针的定义式来定义函数指针变量
2. 定义函数指针数组
3. 函数的形参含有函数指针(回调函数)
4. 函数的返回值是函数指针
5. 函数的返回值和函数的形参都含有函数指针
   如：

#include <stdio.h>
#include <stdlib.h>

int square(int x);
int cube(int x); 

int y;

// 直接使用函薮指针的定义式来定义函数指针变量
int (*PFUN)(int x);

// 定义函数指针数组
int (*a[2])(int x) = {square, cube};

// 函数的形参含有函数指针(回调函数)
int f1(int (*p)(int x), int x)
{
	return (*p)(x);
}

// 函数的返回值是函数指针
int (*f2(int x))(int x)
{
	return a[x];
}

// 函数的返回值和函数的形参都含有函数指针
int (*f3(int (*p)(int x)))(int x)
{
	return p;
}

int main() {
	PFUN = square;  // 将 square 函数赋给函薮指针变量 PFUN
	y = (*PFUN)(2);  // 通过函薮指针变量调用 square 函数
	printf("2的平方为：%d\n", y);
	PFUN = cube;
	y = (*PFUN)(2);
	printf("2的立方为：%d\n", y);
	
	system("pause");

	return 0;
}

int square(int x)
{
	return x * x;
}

int cube(int x)
{
	return x * x * x;
}


运行结果：
2的平方为：4
2的立方为：8

通过typedef简化：
如：

#include <stdio.h>
#include <stdlib.h>

int square(int x);
int cube(int x); 

int y;

// 直接使用函薮指针的定义式来定义函数指针变量
typedef int (*DFUN)(int x);

// 定义函数指针数组
DFUN b[2] = {square, cube};

// 函数的形参含有函数指针(回调函数)
int f4(DFUN p, int x)
{
	return (*p)(x);
}

// 函数的返回值是函数指针
DFUN f5(int x)
{
	return a[x];
}

// 函数的返回值和函数的形参都含有函数指针
DFUN f6(DFUN p)
{
	return p;
}

int main() {
	DFUN p1 = square;
	y = (*p1)(2);
	printf("2的平方为：%d\n", y);
	
	y = (*b[0])(2);
	printf("简化用法y的值为：%d\n", y);
	y = f4(square, 3);
	printf("简化用法y的值为：%d\n", y);
	p1 = f5(1);
	y = (*p1)(2);
	printf("简化用法y的值为：%d\n", y);
	
	system("pause");

	return 0;
}

int square(int x)
{
	return x * x;
}

int cube(int x)
{
	return x * x * x;
}


运行结果：
简化用法y的值为：4
简化用法y的值为：9
简化用法y的值为：8