【C++基础语法入门】7.指针

一、指针的基本概念

指针的作用：通过指针间接访问内存；
内存编号是从0开始记录的，一般用十六进制数字表示；可以通过指针变量保存数据的地址。【可以简单认为：指针就是一个地址】

定义指针（pointer）的语法：数据类型 * 指针变量名;
使用指针的语法：*指针变量名

//定义指针
	int a = 10;
	int* p;
	p = &a;
	//也可以直接使用 int* p = &a;
	cout << "a的地址为：" << &a << endl;
	cout << "指针p为：" << p << endl;

	//使用指针
	//通过解引用的方式（指针前加*）来找到指针指向的内存中的数据
	*p = 1000;
	cout << "a=" << a << endl;
	cout << "*p=" << *p << endl;

指针（p）与变量寻址（&a）等效；
解引用指针（*p）与变量赋值（a）等效。

二、指针所占内存空间

指针也是一种数据类型，在32位操作系统(×86编程)下占4个字节，在64位操作系统（×64编程）下占8个字节。

//指针所占内存空间
	int a = 10;
	int* p = &a;
	cout << "sizeof (int *) = " << sizeof(p) << endl;
	//这里可以直接写p就是输出十进制数

三、空指针和野指针

空指针：指针变量指向内存中编号为0的空间
用途：初始化指针变量
空指针指向的内存是不可以访问，更不可以操作的！ 因为0-255之间的内存编号是系统占用的。

野指针：指针变量指向非法的内存空间
访问野指针会报错！！！
int* p = (int &)0x1100;是不可以的，因为并没有这块内存的仿真权限。
在程序中，一定要尽量避免野指针。

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

四、const修饰指针

const修饰指针有三种情况：
1、常量指针：const修饰指针
指针的指向可以修改，但指针指向的值不可以改。

2、指针常量：const修饰常量
指针的指向不可以修改，但指针指向的值可以改。

3、const既修饰指针，又修饰常量

	int a = 10;
	int b = 10;

	//1. 常量指针
	const int* p1 = &a;
	p1 = &b; //但不可以设置 *p = 20;

	//2. 指针常量
	int* const p2 = &a;
	*p2 = 20; //但不可以设置 p = &b;

	//3. const既修饰指针，又修饰常量
	const int* const p3 = &a;
	//不可以设置 *p = 20;也不可以设置 p = &b;

五、 指针和数组

可以利用指针访问数组中的元素。让指针*p等于数组名就可以得到数组首地址，之后将p++就可访问数组中下一个元素。

int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
cout << "第一个元素为：" << arr[0] << endl;

int* p = arr;//数组名就是数组首地址
cout << "利用指针访问第一个元素：" << *p << endl;

p++;//让指针向后移了4个字节（因为是整型指针，占4个字节）
cout << "利用指针访问第二个元素：" << *p << endl;

cout << "利用指针遍历数组" << endl;
int* p2 = arr;
for (int i = 0; i < 10; i++)
{
	//cout << arr[i] << endl; //直接遍历数组
	cout << *p2 << endl;
	p2++;
}

六、指针和函数

作用：利用指针作函数参数，可以修改实参的值
1.值传递

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

int main()
{
	int a = 10;
	int b = 20;
	swap01(a, b);
}

将主函数中实参a、b的值传递给形参中的a、b，函数中的a和b的值会发生交换，但实参的值并没有改变。

2.地址传递
地址传递可以在函数体内修改实参的值。

void swap02(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
int main()
{
	int a = 10; 
	int b = 20;
	swap02(&a, &b);
	cout << "a的值为：" << a << endl;
	cout << "b的值为：" << b << endl;
}

此时会输出a的值为20，b的值为10。

总结：如果在函数体内想修改实参，就用地址传递；不想修改实参就用值传递！

七、 指针、数组、函数

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序。
例如数组：int arr[10] = {4, 3, 6, 9, 1, 2, 10, 8, 7, 5};

//冒泡排序函数，参数1为数组的首地址，参数2为数组长度
void bubbleSort(int * arr, int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			//如果j > j + 1 ,交换数字
			if (arr[j] > arr[j + 1]) //这里的arr是数组的首地址！！！可以直接用首地址[序号]去访问！！！
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

//打印数组函数
void printArray(int* arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << endl;
	}
}

int main()
{
	//1、先创建数组
	int arr[10] = { 4, 3, 6, 9, 1, 2, 10, 8, 7, 5 };
	
	//数组长度
	int len = sizeof(arr) / sizeof(arr[0]);
	//2、创建函数，实现冒泡排序
	bubbleSort(arr, len);
	//3、打印排序后的数组
	printArray(arr, len);

	system("pause");
	return 0;
}