指针

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

• 内存编号是从0开始记录的，一般用十六进制数字表示
• 可以利用指针变量保存地址（可以理解成指针就是地址）

指针变量的定义和使用

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

#include 
using namespace std;

int main() {
    int a = 10;
    
    int* p;  // 定义一个指针变量
    p = &a;  // 让指针变量p存储数据变量a的内存地址
    
    cout << "a的地址为：" << &a << endl;
    cout << "指针p为：" << p << endl;
    cout << "*p = " << *p << endl;  // 可以通过解引用的方式来找到指针指向的内存地址所存储的数据
    
    *p = 20;  // *p的值就是a的值，因此改变了*p的值也就等于改变了a的值
    
    cout << "a = " << a << endl;
    cout << "*p = " << *p << endl;
    
    system("pause");
    
    return 0;
}
---------
a的地址为：00000052215CF524
指针p为：00000052215CF524
*p = 10
a = 20
*p = 20

在32位操作系统下，任何类型的指针变量都占4个字节的内存空间；
在64位操作系统下，任何类型的指针变量都占8个字节的内存空间。

#include 
using namespace std;

int main() {
    int a = 10;
    
    int* p = &a;
    
    cout << "指针变量p的内存空间大小为：" << sizeof(p) << endl;
    cout << "int类型指针的内存空间大小为：" << sizeof(int*) << endl;
    cout << "float类型指针的内存空间大小为：" << sizeof(float*) << endl;
    cout << "double类型指针的内存空间大小为：" << sizeof(double*) << endl;
    cout << "char类型指针的内存空间大小为：" << sizeof(char*) << endl;
    
    system("pause");
    
    return 0;
}
---------
指针变量p的内存空间大小为：8
int类型指针的内存空间大小为：8
float类型指针的内存空间大小为：8
double类型指针的内存空间大小为：8
char类型指针的内存空间大小为：8

空指针和野指针

空指针：指针变量指向内存中编号为0的地址

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的；内存编号0-255为系统占用内存，不允许用户访问

#include 
using namespace std;

int main() {
	int* p = NULL;  // 定义一个空指针，目的是初始化指针变量p
	
	// cout << *P << endl;  // 空指针不可访问，会出错
	
	system("pause");
	
	return 0;
}

野指针：指针变量指向非法的内存地址

#include 
using namespace std;

int main() {
	int* p = (int*)0x1100;  // 野指针，指向非法内存地址
	
	// cout << *P << endl;  // 访问野指针会报错；程序中应避免出现野指针
	
	system("pause");
	
	return 0;
}

空指针和野指针都不是我们申请的内存空间，因此不要访问。

const修饰指针

const修饰指针有三种情况：

• const修饰指针 – 常量指针
• const修饰常量 – 指针常量
• const既修饰指针，又修饰常量

#include 
using namespace std;

int main() {
	int a = 10;
	int b = 20;
	
	const int* p = &a;  // const修饰的是指针，指针指向可以改，指针指向的值不可以通过解引用更改
	
	cout << "常量指针p为：" << p << endl;
	cout << "常量指针p指向的内存地址存储的数据为：" << *p << endl;
	
	p = &b;  // 修改常量指针p的指向，即存储的内存地址
	
	cout << "常量指针p为：" << p << endl;
	cout << "常量指针p指向的内存地址存储的数据为：" << *p << endl;
	
	// *p = 100;  // 常量指针指向的值不能通过解引用修改，会报错；只能改变其变量值
	
	b = 30;  // 修改变量b的值
	
	cout << *p << endl;  // 变量值改变了，p指向的值也就改变了，解引用得到了改变后的值
	
	system("pause");
	
	return 0;
}
---------
常量指针p为：00000051034FFC44
常量指针p指向的内存地址存储的数据为：10
常量指针p为：00000051034FFC64
常量指针p指向的内存地址存储的数据为：20
30

#include 
using namespace std;

int main() {
	int a = 10;
	int b = 20;
	
	int* const p = &a;  // const修饰的是常量，指针指向不可以改，指针指向的值可以通过解引用更改
	
	cout << "指针常量p为：" << p << endl;
	cout << "指针常量p指向的内存地址存储的数据为：" << *p << endl;
	
	// p = &b;  // 指针常量p的指向不能修改，会报错
	
	*p = 30;  // 通过解引用改变指针p指向的内存地址存储的数据
	
	cout << "指针常量p为：" << p << endl;
	cout << "指针常量p指向的内存地址存储的数据为：" << *p << endl;
	
	a = 100;  // 修改变量a的值
	
	cout << *p << endl;  // 变量值改变了，p指向的值也就改变了，解引用得到了改变后的值
	
	system("pause");
	
	return 0;
}
---------
指针常量p为：000000BDA21FF984
指针常量p指向的内存地址存储的数据为：10
指针常量p为：000000BDA21FF984
指针常量p指向的内存地址存储的数据为：30
100

#include 
using namespace std;

int main() {
	int a = 10;
	int b = 20;
	
	const int* const p = &a;  // const既修饰指针，又修饰常量；指针指向不可更改，指向的值也不能通过解引用更改
	
	cout << "指针p为：" << p << endl;
	cout << "指针p指向的内存地址存储的数据为：" << *p << endl;
	
	// p = &b;  // 指针p的指向不能修改，会报错
	
	// *p = 30;  // 指针p不能通过解引用来修改数据，会报错
	
	a = 100;  // 修改变量a的值
	
	cout << *p << endl;  // 变量值改变了，p指向的值也就改变了，解引用得到了改变后的值
	
	system("pause");
	
	return 0;
}
---------
指针p为：00000021B08FF8B4
指针p指向的内存地址存储的数据为：10
100

指针和数组

作用： 利用指针访问数组中的元素

#include 
using namespace std;

int main() {
	int arr[] = {1, 2, 3, 4, 5, 6, 7};
	
	int* p = arr;  // 创建一个指向数组arr的指针p
	
	cout << "数组的第一个元素为：" << arr[0] << endl;
	cout << "通过指针访问数组的第一个元素：" << *p << endl;
	
	// 利用指针遍历数组
	for(int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		cout << *p << " ";
		
		p++;  // 让指针向后移动4个字节
	}
	
	cout << endl;
	
	system("pause");
	
	return 0;
}
---------
数组的第一个元素为：1
通过指针访问数组的第一个元素：1
1 2 3 4 5 6 7

指针和函数

作用： 将指针作为函数参数，可以修改实参的值

#include 
using namespace std;

void swap1(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
}

void swap2(int* p1, int* p2) {
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main() {
	int a = 10;
	int b = 20;
	
    // 值传递，不会改变实参的值
	swap1(a, b);
	cout << "a = " << a << ", b = " << b << endl;
	
    // 地址传递，会改变实参的值
	swap2(&a, &b);
	cout << "a = " << a << ", b = " << b << endl;
	
	system("pause");
	
	return 0;
}
---------
a = 10, b = 20
a = 20, b = 10

如果不想改变实参，就用值传递；如果想改变实参，就用地址传递。