C++基础（6）——指针

最新推荐文章于 2023-09-13 15:49:38 发布

AI炮灰

最新推荐文章于 2023-09-13 15:49:38 发布

阅读量131

点赞数

分类专栏： C++基础学习与实战文章标签： c++ 指针数据结构

本文链接：https://blog.csdn.net/bigData1994pb/article/details/118634280

版权

C++基础学习与实战专栏收录该内容

25 篇文章 8 订阅

订阅专栏

1.指针基本使用

把指针就当作一个地址。

#include<iostream>
#include"swap.h"
using namespace std;

void main() {
	//1.定义指针:数据类型 * 指针变量名；
	int a = 10;
	int* p;
	//与a建立关系。让指针记录变量a的地址
	p = &a;
	cout << "a的地址为：" << p << endl;//返回的是十六进制的
	cout << "a的地址为：" << (int)p << endl;//返回的是十进制的

	//2.使用指针：可以通过解引用的方式来找到指针指向的内存。指针前加一个*代表解引用，找到指针指向内存的数据
	cout << *p << endl;
	//如果把*p数值改变那么a的值也会变化
	*p = 1000;
	cout << a << endl;
	cout << *p << endl;
}

2.空指针和野指针

2.1空指针

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

用途:初始化指针变量

注意：空指针指向的内存是不可以访问的

如果访问就会出现上面的报错。

2.2 野指针

指指针变量指向非法的内存空间

说明我们没有这个地址的访问权限，因为地址根本没有申请。野指针一般就是一个错误。

3 const修饰指针

const修饰指针有三种情况：

const修饰指针 ——常量指针：指针指向可以修改，但是指针指向的值不可以修改。例如const *p=&a
const修饰常量——指针常量：指针的指向不可以改，但是指针指向的值可以修改。int *const p=&a;
const修饰指针又修饰常量

判断是常量指针还是指针常量，主要看const后面修饰的是谁，如果后面修饰的是指针，就称为常量指针，如果后面修饰的是变量，就称为指针常量。

#include<iostream>
#include"swap.h"
using namespace std;

void main() {
	int a = 10;
	int b = 20;
	//1.const 修饰指针，常量指针
	const int* p = &a;
	//指针指向的值不可以更改，指针的指向可以更改
	//*p = 20;这是错误的
	p = &b;//这是正确的

	//2.const修饰常量
	//指针指向的值可以更改，指针的指向不可以更改
	int* const p2 = &a;
	*p2 = 100;//正确的
	//p2=&b错误的

	//3.const修饰指针和常量
	const int* const p3 = &a;
	//指针的指向和指针指向的值都不可以改
	//*p3=100;错的
	//p3=&b;都是错的
}

4.指针和数值配合使用

#include<iostream>
#include"swap.h"
using namespace std;

void main() {
	//利用指针访问数组中的元素
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;//数组名就是数组的首地址
	cout << "用指针访问数组中的第一个数字:" << *p << endl;
	//利用指针访问数组中每一个元素
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		cout << *p << endl;
		p++;
	}

}

5.指针与函数

5.1值传递

#include<iostream>
#include"swap.h"
using namespace std;

void swap01(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
	cout << a << endl;
	cout << b << endl;
}
int main() {
	//1.值传递
	int a = 10;
	int b = 20;
	swap01(a, b);
	cout << a << endl;
	cout << b << endl;
	return 0;
}

、

可以看到值传递只会改变形参的数值，而不会改变实参的数值。

5.2地址传递

#include<iostream>
#include"swap.h"
using namespace std;

void swap01(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
	//cout << a << endl;
	//cout << b << endl;

}

void swap02(int* p1, int* p2) {//地址传递
	//因为是值变换，所以要把指针解析出来
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
	
}


int main() {
	//1.值传递
	int a = 10;
	int b = 20;
	//swap01(a, b);
	/*cout << a << endl;
	cout << b << endl;*/
	

	//2.地址传递
	swap02(&a, &b);
	cout << a << endl;
	cout << b << endl;
	return 0;
}

可以看到，a,b的值也变化了，形参和实参都改变了。

6.指针、数组和函数组合使用

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

#include<iostream>
#include"swap.h"
using namespace std;

void bubbleSort(int* arr, int len) {//参数1，数组的首地址，参数2 数组长度
	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]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] =temp;
			}
		}
	}

}

void printArr(int* arr, int len) {
	for (int i = 0; i < len; i++) {
		cout << arr[i] << endl;
	}
}


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