C++学习 --指针

qq_25500415

已于 2023-10-08 19:02:52 修改

阅读量66

点赞数

分类专栏： C++ 文章标签： c++ 学习

于 2023-10-07 18:29:03 首次发布

本文链接：https://blog.csdn.net/qq_25500415/article/details/133648458

版权

C++ 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1，什么是指针

指针就是存储地址的变量，指针就是地址

2，指针定义

通过数据类型 * 指针变量名，可定义一个指针变量， 指针数据类型需要和变量数据类型一致

int a = 10;
//定义指针变量p， 指向变量a的地址
int * p = &a;

3，通过指针修改变量

通过*指针变量名=值，可操作指针指向的变量值

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	//定义指针变量p， 指向变量a的地址
	int * p = &a;
	
	cout << "a的地址:" << &a << endl;
	cout << "指针p的地址:" << p << endl;

	//通过指针修改变量的值
	*p = 1000;
	cout << "a的值:" << a << endl;
	cout << "*p的值:" << *p << endl;

	system("pause");

	return 0;
}
-------------------------------------------------------
输出结果：
a的地址:00000096422FFB34
指针p的地址:00000096422FFB34
a的值:1000
*p的值:1000

4，指针占用内存大小

指针占用内存大小与指针类型没有关系， 与操作系统有关系， 32位系统占用4字节， 64位系统占用8字节

#include <iostream>
using namespace std;

int main()
{
	cout << "int型指针占用内存大小：" << sizeof(int *) << endl;
	cout << "float型指针占用内存大小：" << sizeof(float *) << endl;
	cout << "double型指针占用内存大小：" << sizeof(double *) << endl;
	cout << "char型指针占用内存大小：" << sizeof(char *) << endl;
	cout << "string型指针占用内存大小：" << sizeof(string *) << endl;

	system("pause");

	return 0;
}
--------------------------------------------------------------
输出结果：
int型指针占用内存大小：4
float型指针占用内存大小：4
double型指针占用内存大小：4
char型指针占用内存大小：4
string型指针占用内存大小：4

5，空指针

4-1，什么是空指针

地址为0的指针为空指针，用于指针变量初始化，空指针不能访问

4-2，定义空指针

通过数据类型 * 指针变量名 = NULL， 可定义一个空指针

//定义p为一个空指针
int * p = NULL;

6，野指针

指向一个未知的地址的指针，叫着野指针，访问该地址会出错

//定义p为一个野指针
//因为地址0x1100是未知的
//(int*)0x1100表示将0x1100转换为int类型指针
int * p = (int *)0x1100;

7， const修饰指针

7-1，指针常量

通过数据类型 * const 指针变量名称， 可定义一个指针常量， 指向不能修改， 指向的变量值可修改

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	int b = 20;
	//定义p为一个指针常量
	int * const p = &a;

	//指针常量是不能修改指向的，所以下面的不正确
	//p = &b;
	//指针常量可以修改指向的值
	*p = 100;

	cout << "a的值：" << a << endl;
	cout << "*p的值：" << *p << endl;

	system("pause");

	return 0;
}
--------------------------------------------------------------
输出结果：
a的值：100
*p的值：100

7-2，常量指针

通过const 数据类型 * 指针变量名称， 可定义一个常量指针， 指向能修改， 指向的变量值不能修改

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	int b = 20;
	//定义p为一个常量指针
	const int * p = &a;

	//常量指针是不能修改值的，所以下面的不正确
	//*p = 100;
	//常量指针可以修改指向的值
	p = &b;

	cout << "a的值：" << a << endl;
	cout << "*p的值：" << *p << endl;

	system("pause");

	return 0;
}
---------------------------------------------------------------
输出结果：
a的值：10
*p的值：20

7-3，即修饰常量又修饰指针

通过const 数据类型 * const 指针变量名, 可即修饰常量又修饰指针， 该方式修饰的指针，指向和指向的值都不能修改

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	int b = 20;
	//定义p为一个常量指针
	const int * const p = &a;

	//不能修改指向值，所以下面的不正确
	//*p = 100;
	//不能修改指向， 所以下面的不正确
	//p = &b;

	cout << "a的值：" << a << endl;
	cout << "*p的值：" << *p << endl;

	system("pause");

	return 0;
}
-------------------------------------------------------
输出结果：
a的值：10
*p的值：10

8，指针访问数组

#include <iostream>
using namespace std;

int main()
{
	int attr[] = {1, 2, 3, 4, 5, 6};

	//将数组的首地址赋值给指针p
	int * p = attr;

	cout << "通过指针访问数组元素：" << endl;
	for (int i = 0; i < 6; i++)
	{
		cout << *p << endl;
		//p++每次移动到数组的下个元素
		p++;
	}

	system("pause");

	return 0;
}
----------------------------------------------------
输出结果：
1
2
3
4
5
6

9，指针当着函数参数

当指针做为函数实参，调用函数后，实参的值也会发生变化

#include <iostream>
using namespace std;

void swap(int * p1, int * p2)
{
	int tmp = 0;
	tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

int main()
{
	int a = 10;
	int b = 20;
	int * p1 = &a;
	int * p2 = &b;
	
	//指针作为实参传递
	swap(p1, p2);

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

	system("pause");

	return 0;
}
---------------------------------------------------------
输出结果：
a=20
b=10

10，通过指针实现冒泡排序

#include <iostream>
using namespace std;

void bubble_sort(int * attr, int len)
{
	int tmp = 0;

	for (int i=0; i<len-1; i++)
	{
		for (int j=0; j<len-i-1; j++)
		{
			if (attr[j]>attr[j+1])
			{
				tmp = attr[j];
				attr[j] = attr[j+1];
				attr[j+1] = tmp;
			}
		}
	}
}

void print_sort_attr(int * attr, int len)
{
	cout << "排序后的数组为：" << endl;
	for (int i = 0; i < len; i++)
	{
		cout << attr[i] << " ";
	}
	cout << endl;
}

int main()
{
	int attr[] = { 4, 3, 6, 9, 1, 2, 10, 8, 7, 5 };
	int attr_len = sizeof(attr) / sizeof(attr[0]);
	int * p = attr;

	bubble_sort(p, attr_len);
	print_sort_attr(p, attr_len);

	system("pause");

	return 0;
}
----------------------------------------------------
输出结果：
1 2 3 4 5 6 7 8 9 10