指针

指针的基本概念:

**指针的作用:**可以通过指针间接访问内存

  • 内存编号是从0开始记录的,一般用十六进制数字表示。
  • 可以利用指针变量保存地址。

指针变量的定义和使用

指针变量定义语法: 数据类型 * 变量名;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<iostream>
using namespace std;
int main(){

//1、定义指针
int a = 10;
//指针定义的语法: 数据类型 * 变量名
int * p;
//让指针记录变量a的地址
p = &a;
cout << "a的地址为" << a << endl;
cout << "指针p为:" << a << endl;

//2、使用指针
//可以通过解引用的方式来找到指针指向的内存
//指针前加 * 代表解引用,找到指针指向的内存中的数据

*p =1000;
cout << "a =" << a <<endl;
cout << "*p" << *p <<endl;

}

指针所占内存空间

那么,指针作为一种数据类型,占用多少内存空间?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<iostream>
using namespace std;
int main(){
//指针所占内存空间
int a = 10;
//int * p;
//p = &a;
int * p = &a;

cout<< "sizeof (int *)" << sizeof(int *) << endl;

cout << "sizeof (int *) = " << sizeof(int *) << endl;
cout << "sizeof (int *) = " << sizeof(float *) << endl;
cout << "sizeof (int *) = " << sizeof(double *) << endl;
cout << "sizeof (int *) = " << sizeof(char *) << endl;

system("pause");
}

image-20250716111505321

  • 在32位操作系统下,指针是占4个字节空间大小,不管是什么数据类型。

  • 在64位操作系统下,指针是占8个字节空间大小。

空指针和野指针

  • 空指针: 指针变量指向内存中编号为0的空间。
    • 用途:初始化指针变量。
    • 注意:空指针指向的内存是不可访问的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<iostream>
using namespace std;
int main(){
//空指针
//1、空指针用于给指针变量进行初始化
int *p = NULL;

//2、空指针是不可以进行访问的
*p = 100;

system("pause");

return 0;
}

image-20250717090504678

  • 野指针:指针变量指向非法的内存空间
1
2
3
4
5
6
7
8
9
10
11
12
int main(){

//指针变量p指向内存地址编号为0x1100的空间
int * p = (int *)0x1100;

//访问野指针报错
cout<< *p <<endl;

system("pause");

return 0;
}

const修饰指针

const修饰指针有三种情况:

  1. const修饰指针 – 常量指针
  2. const修饰常量 – 指针常量
  3. const既修饰指针,又修饰常量

const修饰指针–常量指针

特点:指针的指向可以修改,但指针指向的值不可以修改。

1
2
3
4
5
6
7
8
9
//这是伪代码
int a = 10;
int b = 10;
int * p = &a;
const int * p = &a //常量指针

*p= 20; //错误,指针指向的值不可以修改
p= &b; //正确,指针的指向可以修改

const修饰常量–指针常量

特点:指针指向的值可以修改,但指针的指向不可以修改。

1
2
3
4
5
6
7
8
//这是伪代码
int a = 10;
int b = 10;
int * p = &a;
int * const p = &a //常量指针

*p= 20; //正确,指针指向的值可以修改
p= &b; //错误,指针的指向不可以修改

const既修饰指针,又修饰常量

特点:指针指向的值和指针的指向都不可以修改。

1
2
3
4
5
6
7
8
//这是伪代码
int a = 10;
int b = 10;
int * p = &a;
int * const p = &a //常量指针

*p= 20; //错误,指针指向的值不可以修改
p= &b; //错误,指针的指向不可以修改

**P.S:**看const右侧紧跟着的是指针还是常量,是指针就是常量指针,是常量就是指针常量