[C++基础学习-06]----C++指针详解

前言

指针是一个存储变量地址的变量，可以用来访问内存中的数据。在C++中，指针是一种非常有用的数据类型，可以帮助我们在程序中对内存进行操作和管理。

正文

01-指针简介

指针的基本概念如下：

声明指针：使用"*"符号来声明指针变量，如int *ptr;表示声明一个指向整型变量的指针。

给指针赋值：可以使用&运算符来获取变量的地址，并将其赋给指针变量，如int a = 10; int *ptr = &a;表示将整型变量a的地址赋给指针ptr。

使用指针访问变量：可以使用*运算符来获取指针指向的变量的值，如int value = *ptr;表示获取指针ptr所指向的整型变量的值。

修改指针指向的变量：可以直接对指针指向的变量进行修改，如*ptr = 20;表示将指针ptr所指向的整型变量的值修改为20。

指针的使用过程中需要注意一些注意事项：

尽量避免野指针：未初始化或指向无效地址的指针会导致程序崩溃或产生未定义行为，因此应该始终确保指针指向有效的内存位置。

避免内存泄漏：使用完指针后应该及时释放内存，否则会导致内存泄漏，造成系统资源浪费。

指针类型要匹配：指针的类型应该与其所指向的变量类型匹配，否则会导致编译错误或程序运行时出错。

02-指针的定义和使用

具体代码和解释如下：

#include<iostream>
using namespace std;

int main()
{
	// 定于一个指针   指针就是一个地址，不是一个值

	int a = 10;

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

	int *p;
	p = &a;   //这里直接将a的地址传递给了p
	cout << "a的地址为：" << &a << endl;
	cout << "p的地址为：" << p << endl;
	// 上述只是p得到a的地址，2、若想得到a的内存，通过解引用的方式可以获得内存
	// 指针前加 * 代表解引用，找到指针指向的内存中的数据
	*p = 1000; // 这里将a和p同时更改
	cout << "a = " << a << endl;
	cout << "p = " << *p << endl;


	system("pause");
	return 0;
}

03-指针所占空间

具体代码和解释如下：

#include<iostream>
using namespace std;

int main()
{
	
	// 指针所占内存空间大小

	int a = 10;
	int * p = &a;
	// 指针在32位操作系统中占有4个字节  无论什么数据类型，都是4个字节 X86 32位  X64 64位
	cout << "sizeof (int *) = " << sizeof(int*) << endl;   //这里写int* 和 p是一样的输出方式  
	cout << "sizeof (int *) = " << sizeof(float*) << endl;
	cout << "sizeof (int *) = " << sizeof(double*) << endl;
	cout << "sizeof (int *) = " << sizeof(char*) << endl;


	system("pause");
	return 0;
}

04-空指针所占空间

具体代码和解释如下：

#include<iostream>
using namespace std;

int main()
{

	// 空指针
	// 1、空指针用于给指针变量进行初始化

	int *p = NULL;   //  NULL代表0

	// 2、空指针是不允许访问的
	// 0~255之间的内存是系统占用的，不可以进行访问
	// *p = 100; 

	system("pause");
	return 0;
}

05-野指针

具体代码和解释如下：

#include<iostream>
using namespace std;

int main()
{

	// 野指针
	// 在主程序中尽量避免出现

	int *p = (int*)0x1100;   //非法空间

	cout << *p << endl;

	system("pause");
	return 0;
}

06-const修饰指针

具体代码和解释如下：

#include<iostream>
using namespace std;

int main()
{

	// const修饰指针的三种情况
	/* 1、常量指针
	   2、指针常量
	   3、const既修饰指针，又修饰常量
	*/
	int a = 10;
	int b = 10;
	const int *p = &a;   

	/* 1、常量指针
	   此时上述代码中的p 使用解引用 获取p的值 *p 但是*p不能进行更改  *p = 20 报错
	   而 p = &b 这样可以更改，也就是说，p的指向可以更改  这叫常量指针
	*/

	int * const p = &a;
	
	/* 2、指针常量
	   此时指的是指针常量，因为，const后加变量指的是常量，这时 *p 可以更改  *p = 20 正确
	   但是 p 的指向不能更改，也就是说 p = &b 将报错 
	*/

	const int * const p = &a;
	/* 3、const既修饰指针，又修饰常量
	   此时无论指针指向还是指向的值都不可以更改
	*/

	system("pause");
	return 0;
}

07-指针与数组

具体代码和解释如下：

#include<iostream>
using namespace std;

int main()
{

	// 利用指针访问数组中的元素
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    
	cout << "第一个元素为：" << arr[0] << endl;
	cout << "第一个元素地址为：" << &arr[0] << endl;
	cout << "第一个元素占有字节为：" << sizeof(arr[0]) << endl;  // 4个字节

	int *p = arr;   // 因为数组名arr就是首地址

	for (int i = 0; i < 10;i++)
	{
		
		cout <<  *p<< endl;
		p++;  // p++一次也就是地址向前加4个字节 ，数组中每一个元素占有四个字节，因此p++相当于从一个元素到下一个元素
		
	}
	

	system("pause");
	return 0;
}

08-指针与函数

具体代码和解释如下：

#include<iostream>
using namespace std;

// 实现两个数字的交换
void swap01(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
	cout << "a =" << a << endl;
	cout << "b = " << 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);
	
	// 2、地址传递
	
	swap02(&a, &b);
	cout << "a =" << a << endl;   // 20
	cout << "b = " << b << endl;  // 10
	/* 上述经过地址传递传递之后，a和b实参也发生了改变，具体原因如下
	   1、首先指针一直存储的都是一个地址，比如 p 就是一个地址，但是加上 *p 之后，
	      这就使用了解引用，此时指的是指针p指向的数值，而不是地址。
       2、上述代码中首先，调用swap02()函数时，使用将a和b的地址传递给p1和p2，
	      此时 p1=a的地址，p2=b的地址。而*p1=10，*p2=20
	   3、swap02()函数时进行数值更换的函数，*p1表示对应a的地址指向的a的数值，
	      *p2指的是对应于b的地址指向的b的数值，而该函数，将*p2赋值给了*p1，*p1赋值给了*p2
		  造成a和b的地址发生改变，地址对应的数值也发生改变  传递地址，将间接改变实参的数据
	      
	*/

	system("pause");
	return 0;
}

09-指针数组函数案例

具体代码、解释和运行结果如下：

#include <iostream>
using namespace std;

// 创建冒泡排序函数

void bubbleSort(int *arr, int len)
{
	for (int i = 0; i < len-1;i++)
	{
		for (int j = 0; j < len - i - 1;j++)
		{
			// 如果arr[j]>arr[j+1]，则两个数进行交换
			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()
{
	// 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;

}

总结

指针是C++中非常重要的概念，可以帮助我们更灵活地对内存进行操作，但在使用指针时需要注意避免常见的问题，以确保程序的稳定性和安全性。