C++ - 指针

7 指针

7.1 指针的基本概念

指针的作用： 可以通过指针间接访问内存

 

  • 内存编号是从0开始记录的，一般用十六进制数字表示

  • 可以利用指针变量保存地址

     

7.2 指针的定义和使用

指针变量定义语法： 数据类型 * 变量名；

示例：

int main() {

	//1、指针的定义
	int a = 10; //定义整型变量a
	
	//指针定义语法： 数据类型 * 变量名 ;
	int * p;

	//指针变量赋值
	p = &a; //指针指向变量a的地址
	cout << &a << endl; //打印数据a的地址
	cout << p << endl;  //打印指针变量p

	//2、指针的使用
	//通过*操作指针变量指向的内存
	cout << "*p = " << *p << endl;

	system("pause");

	return 0;
}

 

指针变量和普通变量的区别

  • 普通变量存放的是数据,指针变量存放的是地址

  • 指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用

 

总结1： 我们可以通过 & 符号 获取变量的地址

总结2：利用指针可以记录地址

总结3：对指针变量解引用，可以操作指针指向的内存

 

在规范化声明指针时，一般将其直接初始化地址或置为空指针，而非不做操作形成野指针。例如下面的定义：

int* var;  //野指针，危险
int* var1 = NULL;  //空指针，安全
int* var2 = &var3; //已初始化，安全

 

7.3 指针所占内存空间

 

提问：指针也是种数据类型，那么这种数据类型占用多少内存空间？

 

示例：

int main() {

	int a = 10;

	int * p;
	p = &a; //指针指向数据a的地址

	cout << *p << endl; //* 解引用
	cout << sizeof(p) << endl;
	cout << sizeof(char *) << endl;
	cout << sizeof(float *) << endl;
	cout << sizeof(double *) << endl;

	system("pause");

	return 0;
}

 

总结：所有指针类型在32位操作系统下是4个字节，64位操作系统下是8个字节

 

 

7.4 空指针和野指针

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

用途：初始化指针变量

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

 

示例1：空指针

int main() {

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

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

	system("pause");

	return 0;
}

 

 

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

示例2：野指针

int main() {

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

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

	system("pause");

	return 0;
}

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

 

 

7.5 const修饰指针

const修饰指针有三种情况

  1. const修饰指针 --- 常量指针

  2. const修饰常量 --- 指针常量

  3. const即修饰指针，又修饰常量

示例：

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右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量

 

 

7.6 指针和数组

作用：利用指针访问数组中元素

示例：

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;
}

 

 

7.7 指针作函数参数

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

示例：

//值传递
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 = temp;
}

int main() {

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

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

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

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

	system("pause");

	return 0;
}

 

总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递

 

 

7.8 指针、数组、函数

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

例如数组：int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };

示例：

//冒泡排序函数
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;
}

总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针

 

 

7.9 指针数组和数组指针

如何区分指针数组与数组指针？

一般来说什么东西在后面就是什么东西

数组指针的定义仅仅只是在指针数组定义上加上了一个括号；

int *p[5];          -----   指针数组

int (*p)[5];        -----   数组指针

我们可以这么理解，当没有小括号时，因为方括号[] 优先级高于星号，故p先与方括号结合，形成数组，拿下方括号，剩下的便是数组的类型；而第二组，由于小括号，p先于*组合，形成指针，拿去星号，便是该指针指向的数据类型。

 

指针数组

　　　　本质就是数组；多个一级指针的集合；对于指针数组通常是用来处理字符串的；

　　　　定义指针数组：int* pArray[3]

 #include <stdio.h>
​
//指针数组充当函数参数
void myPrintf(char* pArray[], int len)
{
    for (int i = 0; i < len; i++)
    {
        printf("%s", pArray[i]);
    }
}
​
​
int main()
{
    //定义一个字符数组并初始化
    char Array[5] = "qwer";
​
    //定义一个指针数组并初始化
    char* pArray[3] = { "abc","def","jhi" };
​
    printf("Array[5] = %s\n\n", Array);
​
​
    printf("通过数组下标来访问：\n");
    for (int i = 0; i < 3; i++)
    {
        printf("%s", pArray[i]);
    }
​
​
    printf("\n\n通过指针偏移来访问：\n");
    for (int i = 0; i < 3; i++)
    {
        printf("%s", *(pArray + i));
    }
​
    printf("\n\n指针数组充当函数参数：\n");
    myPrintf(pArray,3);
​
    return 0;
}

运行结果：

示例2：int类型的指针数组使用

#include <iostream>
using namespace std;

int main()

{
	int* ptrArray[5]; // 指针数组，可以存储5个整型指针
	int size = 10; // 每个指针将要指向的整数数量

	// 为每个指针动态分配内存，并初始化
	for (int i = 0; i < 5; ++i) 
	{
		ptrArray[i] = new int[size]; // 为每个指针分配10个整数的内存
		for (int j = 0; j < size; ++j) 
		{
			ptrArray[i][j] = i + j; // 初始化数组元素为i和j的乘积
		}
	}

	// 打印并释放内存
	for (int i = 0; i < 5; ++i) 
	{
		for (int j = 0; j < size; ++j) 
		{
			cout << ptrArray[i][j] << "\t";
		}
		cout << endl;
		delete[] ptrArray[i]; // 释放每个指针指向的内存
	}


	system("pause");
	return 0;
}

执行结果：

 

数组指针

　　　　本质就是指针；产生的是一个指针变量，指针变量指向的是一个数组；对于数组指针通常是用来表示二维数组的；

　　　　定义数组指针：int(*pArray)[3]

 #include <stdio.h>
​
​
//数组指针充当函数参数
void myPrintf(int(*pArray)[4], int row, int clos)
{
    printf("\n数组指针充当函数参数：\n");
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < clos; j++)
        {
            printf("%d\t", pArray[i][j]);
        }
        printf("\n");
    }
}
​
​
int main()
{
    int Array[3][4] = { {2,1,4,0},
                        {3,7,2,5},
                        {5,9,6,6}
                      };
    //定义一个数组指针并初始化
    int(*pArray)[4] = Array;
​
​
    printf("\n通过数组下标来访问：\n");
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            printf("%d\t", pArray[i][j]);
        }
        printf("\n");
    }
​
    printf("\n通过指针偏移来访问：\n");
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            printf("%d\t", *(*(pArray+i)+j));
        }
        printf("\n");
    }
​
    myPrintf(Array, 3, 4);
​
    return 0;
}
​

运行结果：

 

7.10 指针什么时候需要申请内存空间？

看需要：例如你需要把数据存到栈区就不需要开内存，直接使用指针指向一个类型；例如你需要把数据存到堆区就需要开内存

示例1：int类型指针

	int *p;//只有地址，没有内存空间。这个地址是随机地址。

（1）没有申请内存空间：指针不能直接赋值，一般需要指向一个类型（int、char、double）。

	int *p;
	*p = 1;
	cout << *p << endl;

	//错误!指针变量q没有空间，不能直接存放数据。

编译器错误提示：

（2）开辟到栈区：把数据存放到栈区

	int *p;//定义指针p
	int a = 1;//定义int类型a
	p = &a;//指针p指向a这块内存地址
	cout <<"p = "<<*p << endl;//解引用

（3）开辟到堆区：如果要给指针直接赋值的话，必须采用动态内存申请的方式赋值。

	int *p = new int;
	*p = 1;
	cout <<"p = "<<*p << endl;//解引用

//正确，存放数据之前给指针变量申请了一个int类型大小的堆内存空间。

 

示例2：struct类型指针

struct student
{
	int id;
	char name[20];
	int age;
	double score;
};

（1）没有申请内存空间：指针不能直接赋值，一般需要指向一个类型（int、char、double）。

	struct student* p;

	p->id = 1;
	strcpy(p->name, "张三");
	p->age = 33;
	p->score = 1.33;
	//错误!指针变量p没有空间，不能直接存放数据。

	cout << "p->id = " << p->id;
	cout << "p->name = " << p->name;
	cout << "p->age = " << p->age;
	cout << "p->score = " << p->score;

编译器错误提示：

（2）开辟到栈区：把数据存放到栈区

	struct student stu;//定义一个结构体

	//初始化结构体
	stu.id = 1001;
	strcpy(stu.name, "张三");
	stu.age = 33;
	stu.score = 1.333;

	struct student* p = &stu;//定义一个结构体指针，并指向结构体stu

	cout << "p->id = " << p->id << endl;
	cout << "p->name = " << p->name << endl;
	cout << "p->age = " << p->age << endl;
	cout << "p->score = " << p->score << endl;

（3）开辟到堆区：如果要给指针直接赋值的话，必须采用动态内存申请的方式赋值。

	student* p = new student();//动态内存申请

	p->id = 1;
	strcpy(p->name, "张三");
	p->age = 33;
	p->score = 1.33;

	cout << "p->id = " << p->id << endl;
	cout << "p->name = " << p->name << endl;
	cout << "p->age = " << p->age << endl;
	cout << "p->score = " << p->score << endl;
//正确，存放数据之前给指针变量申请了一个student类型大小的堆内存空间。

 

7.11 指针什么时候需要释放内存空间

在C++中，动态分配的内存需要手动释放，以避免内存泄漏。以下是需要释放内存的情况：

1. 使用 `new` 操作符分配的内存：当你使用 `new` 来分配内存时，必须使用 `delete` 来释放。

2. 使用 `new[]` 分配数组：当你使用 `new[]` 分配数组时，必须使用 `delete[]` 来释放。

 

不需要释放的情况：

- 栈上的内存（局部变量）会自动释放。

- 静态变量和全局变量在程序结束时自动释放。

- 通过智能指针（如 `unique_ptr`, `shared_ptr`）管理的内存会自动释放。

 

重要原则：

- 每个 `new` 必须对应一个 `delete`。

- 每个 `new[]` 必须对应一个 `delete[]`。

- 避免重复释放（会导致未定义行为，通常程序崩溃）。

- 释放后应将指针置为 `nullptr`，以避免悬挂指针（但注意，这并不能防止所有悬挂指针问题）。

 

必须释放内存的情况：

  1. 使用 new 分配单个对象

     
    int* ptr = new int(10);  // 动态分配
// 使用 ptr...
delete ptr;  // 必须手动释放！
ptr = nullptr; // 避免悬空指针（可选但推荐）

  2. 使用 new[] 分配数组

     
    int* arr = new int[100];  // 动态数组
// 使用 arr...
delete[] arr;  // 必须用 delete[] 释放！
arr = nullptr;

  3. 在类中动态分配成员

     
    class MyClass {
public:
    int* data;
    MyClass(int size) : data(new int[size]) {}
    ~MyClass() { delete[] data; } // 必须在析构函数中释放
};

不需要释放内存的情况：

  1. 栈内存（自动管理）

    int num = 10;      // 栈内存，自动回收
int stackArr[100]; // 栈数组，自动回收
int* p = &num      // 栈内存，自动回收

  2. 静态或全局变量

    static int s_var;  // 程序结束时自动释放

  3. 智能指针管理的对象

    #include <memory>
std::unique_ptr<int> smartPtr = std::make_unique<int>(20);
// 自动释放，无需手动 delete

  4. 其他资源管理对象

    std::vector<int> vec;  // STL 容器自动管理内存
std::string str;       // 字符串自动管理内存

     

     

posted @ 2023-10-11 14:46  [BORUTO]  阅读(30)  评论(0)    收藏  举报