指针
普通指针: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
函数指针
数指针的使用形式:
- 直接使用函薮指针的定义式来定义函数指针变量
- 定义函数指针数组
- 函数的形参含有函数指针(回调函数)
- 函数的返回值是函数指针
- 函数的返回值和函数的形参都含有函数指针
如:
#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