概述
- 内存地址
- 在计算机内存中，每个存储单元都有一个唯一的地址(内存编号)。
- 通俗理解，内存就是房间，地址就是门牌号
- 指针和指针变量
- 指针（Pointer）是一种特殊的变量类型，它用于存储内存地址。
- 指针的实质就是内存"地址"
- 指针变量就是存储这个地址的变量。
- 指针作用
- 可间接修改变量的值
指针变量的定义和使用
- 指针也是一种数据类型，指针变量也是一种变量
- 指针变量指向谁，就把谁的地址赋值给指针变量
- 语法格式：
类型 变量;
类型 * 指针变量 = &变量;
- & 叫取地址，返回操作数的内存地址
- * 叫解引用，指操作指针所指向的变量的值
- 在定义变量时，* 号表示所声明的变量为指针类型
- 指针变量要保存某个变量的地址，指针变量的类型比这个变量的类型多一个*
- 指针使用时，* 号表示操作指针所指向的内存空间
cpp
#include <stdio.h>
int main() {
// 定义一个int类型的变量，同时赋值为10
int a = 10;
// 打印变量的地址
printf("&a = %p\n", &a);
// 定义一个指针变量，int *保存int的地址
// int *代表是一种数据类型，int *指针类型，p才是变量名
int* p;
// 指针指向谁，就把谁的地址赋值给这个指针变量
p = &a;
// 打印p, *p, p指向了a的地址，*p就是a的值
printf("p = %p, *p = %d\n", p, *p);
return 0;
}
通过指针间接修改变量的值
- 指针变量指向谁，就把谁的地址赋值给指针变量
- 通过 *指针变量 间接修改变量的值
cpp
#include <stdio.h>
int main() {
// 定义一个int类型变量a，同时赋值为0
int a = 0;
// 定义int *指针变量，同时赋值a的地址
int *p = &a;
// 通过指针间接修改a的值
*p = 123;
printf("a = %d\n", a);
// 定义一个int类型变量b，同时赋值为5
int b = 5;
// p 保存 b的地址
p = &b;
// 通过指针间接修改b的值
*p = 250;
printf("b = %d\n", b);
return 0;
}指针与常量
- 语法格式
cpp
int a = 1;
const int *p1 = &a; // 等价于 int const *p1 = &a;
int * const p2 = &a;
const int * const p3 = &a;- 从左往右看，跳过类型，看修饰哪个字符
- 如果是*， 说明指针指向的内存不能改变
- 如果是指针变量，说明指针的指向不能改变，指针的值不能修改
cpp
#include <stdio.h>
int main() {
int a = 1;
int b = 2;
// p1 可以改，*p1不能改
const int *p1 = &a; // 等价于 int const *p1 = &a;
// p1 = &b; // ok
// *p1 = 555; // err
// p2 不能修改，*p2可以修改
int *const p2 = &a;
// p2 = &b; //err
// *p2 = 555; // ok
// p3 和 *p 都不能改
const int *const p3 = &a;
// p3 = &b; // err
// *p3 = 555; // err
return 0;
}指针大小
- 使用sizeof()测量指针的大小，得到的总是：4或8
- sizeof()测的是指针变量指向存储地址的大小
- 在32位平台，所有的指针（地址）都是32位(4字节)
- 在64位平台，所有的指针（地址）都是64位(8字节)
cpp
#include <stdio.h>
int main() {
int *p1;
int **p2;
char *p3;
char **p4;
printf("sizeof(p1) = %llu\n", sizeof(p1));
printf("sizeof(p2) = %llu\n", sizeof(p2));
printf("sizeof(p3) = %llu\n", sizeof(p3));
printf("sizeof(p4) = %llu\n", sizeof(p4));
printf("sizeof(double *) = %llu\n", sizeof(double *));
return 0;
}指针步长
- 指针步长指的是通过指针进行递增或递减操作时，指针所指向的内存地址相对于当前地址的偏移量。
- 指针的步长取决于所指向的数据类型。
- 指针加n等于指针地址加上 n 个 sizeof(type) 的长度
- 指针减n等于指针地址减去 n 个 sizeof(type) 的长度
cpp
#include <stdio.h>
int main() {
char ch;
char *p1 = &ch;
printf("p1:%p, p1+1: %p\n", p1, p1 + 1); // 步长为1字节
int a;
int *p2 = &a;
printf("p2:%p, p2+1: %p\n", p2, p2 + 1); // 步长为4字节
double d;
double *p3 = &d;
printf("p3:%p, p3+1: %p\n", p3, p3 + 1); // 步长为8字节
return 0;
}野指针和空指针
- 指针变量也是变量，是变量就可以任意赋值
- 任意数值赋值给指针变量没有意义，因为这样的指针就成了野指针
- 此指针指向的区域是未知(操作系统不允许操作此指针指向的内存区域)
- 野指针不会直接引发错误，操作野指针指向的内存区域才会出问题
- 为了标志某个指针变量没有任何指向，可赋值为NULL
- NULL是一个值为0的宏常量
cpp
#include <stdio.h>
int main() {
int *p;
p = 0x12345678; // 给指针变量p赋值，p为野指针， ok，不会有问题，但没有意义
// *p = 1000; // 操作野指针指向未知区域，内存出问题，err
printf("111111111111111111\n");
int *q = NULL; // 空指针
return 0;
}多级指针
- C语言允许有多级指针存在，在实际的程序中一级指针最常用，其次是二级指针。
- 二级指针就是指向一个一级指针变量地址的指针
cpp
#include <stdio.h>
int main() {
int a = 100;
// 一级指针
int* p1 = &a;
printf("&a=%p\n", &a);
printf("p1=%p\n", p1);
printf("&p1=%p\n", &p1);
// 二级指针，可以存储一级指针变量的地址
int** p2 = &p1;
printf("p2=%p\n", p2);
printf("&p2=%p\n", &p2);
// 三级指针，可以存储二级指针变量的地址
int*** p3 = &p2;
printf("p3=%p\n", p3);
printf("&p3=%p\n", &p3);
printf("---------------------\n");
// 通过一级指针访问100，打印出来
printf("*p1=%d\n", *p1);
// 通过二级指针访问100，打印出来
printf("**p2=%d\n", **p2);
// 通过三级指针访问100，打印出来
printf("***p3=%d\n", ***p3);
return 0;
}函数参数传值
●传值是指将参数的值拷贝一份传递给函数，函数内部对该参数的修改不会影响到原来的变量
示例代码：
cpp
// 函数参数传值，函数内部交换2个变量的值，验证函数外部的变量有没有改变
#include <stdio.h>
// 函数定义
void func(int m, int n) {
// 函数内部交换2个变量的值
int temp = m;
m = n;
n = temp;
printf("函数内部 m = %d, n = %d\n", m, n);
}
int main() {
int a = 10;
int b = 20;
// 调用函数，值传递
func(a, b);
printf("函数外部 a = %d, b = %d\n", a, b);
return 0;
}运行结果:
cpp
函数内部 m = 20, n = 10
函数外部 a = 10, b = 20函数参数传址
- 传址是指将参数的地址传递给函数，函数内部可以通过该地址来访问原变量，并对其进行修改。
示例代码：
cpp
// 函数参数传地址，函数内部交换2个指针指向内存的值，验证函数外部的变量有没有改变
#include <stdio.h>
// 函数定义
void func(int *m, int *n) {
// 函数内部交换2个指针指向内存的值
int temp = *m;
*m = *n;
*n = temp;
printf("函数内部 *m = %d, *n = %d\n", *m, *n);
}
int main() {
int a = 10;
int b = 20;
// 调用函数，地址传递
func(&a, &b);
printf("函数外部 a = %d, b = %d\n", a, b);
return 0;
}运行结果：
cpp
函数内部 *m = 20, *n = 10
函数外部 a = 20, b = 10函数参数传址
- 传址是指将参数的地址传递给函数，函数内部可以通过该地址来访问原变量，并对其进行修改。
cpp
// 函数参数传地址，函数内部交换2个指针指向内存的值，验证函数外部的变量有没有改变
#include <stdio.h>
// 函数定义
void func(int *m, int *n) {
// 函数内部交换2个指针指向内存的值
int temp = *m;
*m = *n;
*n = temp;
printf("函数内部 *m = %d, *n = %d\n", *m, *n);
}
int main() {
int a = 10;
int b = 20;
// 调用函数，地址传递
func(&a, &b);
printf("函数外部 a = %d, b = %d\n", a, b);
return 0;
}运行结果：
函数内部 *m = 20, *n = 10
函数外部 a = 20, b = 10
函数指针
函数名
- 一个函数在编译时被分配一个入口地址，这个地址就称为函数的指针，函数名代表函数的入口地址
cpp
#include <stdio.h>
void func(int a) {
printf("func a = %d\n", a);
}
int main() {
// 函数名字，就是代表函数的入口地址，函数地址
printf("%p, %p, %p\n", func, &func, *func);
// 3种调用方法都可以
func(1); // 最简便，最常用
(&func)(2);
(*func)(3);
return 0;
}函数指针
- 函数指针：它是指针，指向函数的指针
- 语法格式：
cpp
返回值 (*函数指针变量)(形参列表);函数指针变量的定义，其中返回值、形参列表需要和指向的函数匹配
cpp
#include <stdio.h>
void func(int a) {
printf("a = %d\n", a);
}
int main() {
// 函数指针变量的定义，同时初始化
void (*p1)(int a) = func;
// 通过函数指针变量调用函数
p1(10);
// 先定义函数指针变量，后面再赋值
void (*p2)(int);
p2 = func;
// 通过函数指针变量调用函数
p2(20);
return 0;
}回调函数
- 函数指针变量做函数参数，这个函数指针变量指向的函数就是回调函数
- 回调函数可以增加函数的通用性
- 在不改变原函数的前提下，增加新功能
cpp
#include <stdio.h>
// 定义函数，函数指针做形参
int calc(int a, int b, int (*p)(int, int)){
// 通过函数指针变量调用函数，获取返回值
int res = p(a, b);
return res;
}
// 定义加法函数
int add(int x, int y) {
return x + y;
}
// 定义减法函数
int sub(int x, int y) {
return x - y;
}
int main() {
int result;
// 回调加法函数
result = calc(1, 2, add);
printf("result = %d\n", result);
// 回调减法函数
result = calc(10, 5, sub);
printf("result = %d\n", result);
return 0;
}