6指针

6.1指针的定义和使用

指针就是地址
&表示取地址，&i 是取 i 变量所在的地址编号嘛
pi = &i 就是把 i 地址的编号赋值给 pi

#include <iostream>
#include <stdlib.h>
 
using namespace std;
 
int _tmain(int argc, _TCHAR* argv[])
{
	int i = 30;
 
	std::cout << "&i = "<< &i << std::endl;
	std::cout << "i =  " << i << std::endl;
 
	int *pi = &i;
	std::cout << "*pi = " << *pi << std::endl;
 
	system("pause");
	return 0;
}

![在这里插入图片描述]https://img-blog.csdnimg.cn/711e92a877f044698af7d7296bb2fb87.png)
*表示根据地址找出对应内存单元的数据
*pi 就是pi 所指地址的内容。例如上面pi存放的是变量i的地址，*p就是地址对应的变量i所存放的数据，也就是30。
int p 可以把int看作一种数据类型，p看作变量

6.2空指针和野指针

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

用途：初始化指针变量

[注]：空指针指向的内存是不可以访问的
野指针：指针变量指向非法的内存空间

//空指针
int main() {

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

	//访问空指针报错 
	//内存编号0 ~255为系统占用内存，不允许用户访问
	cout << *p << endl;

	system("pause");

	return 0;
}
//野指针
int main() {

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

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

	system("pause");

	return 0;
}
//总结：空指针和野指针都不是我们申请的空间，因此不要访问

6.3const修饰指针

const修饰指针有三种情况:

const修饰指针 — 常量指针 (const int * p1)
const修饰常量 — 指针常量 (int * const p1)
const既修饰指针，又修饰常量 (const int * const p3) :

int main() {

	int a = 10;
	int b = 10;

	//常量指针：const修饰的是指针，指针所指向的内容是常量不可变
	const int * p1 = &a; 
	p1 = &b; //正确
	//*p1 = 100;  报错
	

	//const修饰的是常量，指针本身是常量不可变，
	int * const p2 = &a;
	//p2 = &b; //错误
	*p2 = 100; //正确

    //const既修饰指针又修饰常量，指针所指向的内容和指针本身是常量不可变
	const int * const p3 = &a;
	//p3 = &b; //错误
	//*p3 = 100; //错误

	system("pause");

	return 0;
}

看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量

6.4指针，数组和函数

6.4.1指针和数组

//作用：利用指针访问数组中元素
int main() {
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int * p = arr;  //指向数组的指针
	cout << "第一个元素： " << arr[0] << endl;
	cout << "指针访问第一个元素： " << *p << endl;
	for (int i = 0; i < 10; i++)
	{
		//利用指针遍历数组
		cout << *p << endl;
		p++;
	}
	system("pause");
	return 0;
}

6.4.2指针和函数

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

//值传递
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地址里面的值赋予给p1地址里面的值
	*p2 = temp;
}

int main() {

	int a = 10;
	int b = 20;
	swap1(a, b); // 值传递不会改变实参

	swap2(&a, &b); //地址传递会改变实参

	cout << "a = " << a << endl;//a=10,b=20

	cout << "b = " << b << endl;

	system("pause");

	return 0;
}
//总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递

6.4.3指针，数组和函数

egg：封装一个函数，利用冒泡排序，实现对整型数组的升序排序

//冒泡排序函数
void bubbleSort(int * arr, int len)  //int * arr 也可以写为int arr[]
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				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() {

	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	int len = sizeof(arr) / sizeof(int);

	bubbleSort(arr, len);

	printArray(arr, len);

	system("pause");

	return 0;
}