目录
摘要
在C++中，双指针和三指针分别是指向指针的指针和指向指向指针的指针。它们的主要作用是处理复杂的数据结构、动态内存分配以及通过函数参数修改指针。它们的详细解释、使用场景以及具体示例，我有贴一些代码在相关内容下面。（仅供参考使用）
双指针（Double Pointers）
含义
双指针是指向指针的指针，声明形式如下：
int **ptr;
这里，`ptr` 是一个双指针，它保存的是一个指针的地址，该指针指向一个整数。
使用场景
1. 动态二维数组：
双指针可以用来动态分配和管理二维数组。
#include <iostream>
using namespace std;
int main() {
int rows = 3, cols = 4;
int **array = new int*[rows];
for (int i = 0; i < rows; ++i) {
array[i] = new int[cols];
}
// 初始化并打印数组内容
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
array[i][j] = i * cols + j;
cout << array[i][j] << " ";
}
cout << endl;
}
// 释放分配的内存
for (int i = 0; i < rows; ++i) {
delete[] array[i];
}
delete[] array;
return 0;
}
2. 函数参数修改指针：
通过传递双指针到函数，可以在函数中修改原始指针的值。
#include <iostream>
using namespace std;
void modifyPointer(int **ptr) {
*ptr = new int(10); // 分配一个新整数并修改原始指针以指向它
}
int main() {
int *p = nullptr;
modifyPointer(&p); // 将指针的地址传递给函数
cout << *p << endl; // 输出应该是 10
delete p; // 释放分配的内存
return 0;
}
3. 复杂数据结构：
双指针常用于实现链表、树等复杂数据结构的插入和删除操作。
// 二维链表
#include <iostream>
using namespace std;
// 定义二维链表节点的结构
struct Node {
int value;
Node* right;
Node* down;
Node(int val) : value(val), right(nullptr), down(nullptr) {}
};
// 创建简单二维链表的函数
Node* create2DLinkedList(int rows, int cols) {
Node* head = new Node(0);
Node* rowNode = head;
for (int i = 0; i < rows; ++i) {
Node* colNode = rowNode;
for (int j = 0; j < cols; ++j) {
if (j > 0) {
colNode->right = new Node(i * cols + j);
colNode = colNode->right;
}
}
if (i > 0) {
rowNode->down = new Node(i * cols);
rowNode = rowNode->down;
}
}
return head;
}
// 打印二维链表的功能
void print2DLinkedList(Node* head) {
Node* rowNode = head;
while (rowNode != nullptr) {
Node* colNode = rowNode;
while (colNode != nullptr) {
cout << colNode->value << " ";
colNode = colNode->right;
}
cout << endl;
rowNode = rowNode->down;
}
}
// 删除二维链表和释放内存的功能
void delete2DLinkedList(Node* head) {
Node* rowNode = head;
while (rowNode != nullptr) {
Node* colNode = rowNode;
while (colNode != nullptr) {
Node* tempCol = colNode;
colNode = colNode->right;
delete tempCol;
}
Node* tempRow = rowNode;
rowNode = rowNode->down;
delete tempRow;
}
}
int main() {
int rows = 3, cols = 4;
Node* head = create2DLinkedList(rows, cols);
cout << "2D Linked List Values:" << endl;
print2DLinkedList(head);
delete2DLinkedList(head);
return 0;
}
三指针（Triple Pointers）
含义
三指针是指向指向指针的指针，声明形式如下：
int ***ptr;
这里，`ptr` 是一个三指针，它保存的是一个双指针的地址，该双指针指向一个指针，该指针指向一个整数。
使用场景
1. 动态三维数组：
三指针可以用来动态分配和管理三维数组。
#include <iostream>
using namespace std;
int main() {
int x = 3, y = 4, z = 2;
int ***array = new int**[x];
for (int i = 0; i < x; ++i) {
array[i] = new int*[y];
for (int j = 0; j < y; ++j) {
array[i][j] = new int[z];
}
}
// 初始化并打印数组
for (int i = 0; i < x; ++i) {
for (int j = 0; j < y; ++j) {
for (int k = 0; k < z; ++k) {
array[i][j][k] = i * y * z + j * z + k;
cout << array[i][j][k] << " ";
}
cout << endl;
}
cout << endl;
}
// 释放分配的内存
for (int i = 0; i < x; ++i) {
for (int j = 0; j < y; ++j) {
delete[] array[i][j];
}
delete[] array[i];
}
delete[] array;
return 0;
}
2. 更复杂的数据结构：
在一些极其复杂的数据结构中，可能需要三指针来管理多级嵌套的指针关系。
// 三维链表
#include <iostream>
using namespace std;
// 定义三维链表节点的结构
struct Node {
int value;
Node* nextX;
Node* nextY;
Node* nextZ;
Node(int val) : value(val), nextX(nullptr), nextY(nullptr), nextZ(nullptr) {}
};
// 创建三维链表的函数
Node* create3DLinkedList(int xSize, int ySize, int zSize) {
Node* head = new Node(0);
Node* xNode = head;
for (int i = 0; i < xSize; ++i) {
Node* yNode = xNode;
for (int j = 0; j < ySize; ++j) {
Node* zNode = yNode;
for (int k = 0; k < zSize; ++k) {
if (k > 0) {
zNode->nextZ = new Node((i * ySize * zSize) + (j * zSize) + k);
zNode = zNode->nextZ;
}
}
if (j > 0) {
yNode->nextY = new Node((i * ySize * zSize) + (j * zSize));
yNode = yNode->nextY;
}
}
if (i > 0) {
xNode->nextX = new Node(i * ySize * zSize);
xNode = xNode->nextX;
}
}
return head;
}
// 打印三维链表的功能
void print3DLinkedList(Node* head, int xSize, int ySize, int zSize) {
Node* xNode = head;
for (int i = 0; i < xSize; ++i) {
Node* yNode = xNode;
for (int j = 0; j < ySize; ++j) {
Node* zNode = yNode;
for (int k = 0; k < zSize; ++k) {
cout << zNode->value << " ";
zNode = zNode->nextZ;
}
cout << endl;
yNode = yNode->nextY;
}
cout << endl;
xNode = xNode->nextX;
}
}
// 删除三维链表和释放内存的功能
void delete3DLinkedList(Node* head) {
Node* xNode = head;
while (xNode != nullptr) {
Node* yNode = xNode;
while (yNode != nullptr) {
Node* zNode = yNode;
while (zNode != nullptr) {
Node* tempZ = zNode;
zNode = zNode->nextZ;
delete tempZ;
}
Node* tempY = yNode;
yNode = yNode->nextY;
delete tempY;
}
Node* tempX = xNode;
xNode = xNode->nextX;
delete tempX;
}
}
int main() {
int xSize = 3, ySize = 3, zSize = 3;
Node* head = create3DLinkedList(xSize, ySize, zSize);
cout << "3D Linked List Values:" << endl;
print3DLinkedList(head, xSize, ySize, zSize);
delete3DLinkedList(head);
return 0;
}
3. 高级指针操作：
在某些高级算法和系统编程中，三指针可能被用到。
总结
双指针的详细说明
1. 声明和初始化：
- 双指针的声明形式是 `type **ptr;`，例如 `int **ptr;`。
- 初始化时，可以通过动态内存分配来创建指向指针的指针。
2. 动态二维数组的使用：
- 分配内存：使用循环为每一行分配内存。
- 访问元素：通过双重下标访问数组元素，如 `array[i][j]`。
- 释放内存：首先释放每一行的内存，然后释放指针数组。
3. 函数参数修改指针：
- 通过传递指针的地址到函数中，可以在函数内部修改指针的值。
- 示例代码展示了如何在函数中分配新内存并修改原始指针。
三指针的详细说明
1. 声明和初始化：
- 三指针的声明形式是 `type ***ptr;`，例如 `int ***ptr;`。
- 初始化时，可以通过多级动态内存分配来创建指向指向指针的指针。
2. 动态三维数组的使用：
- 分配内存：使用嵌套循环为每一维度分配内存。
- 访问元素：通过三重下标访问数组元素，如 `array[i][j][k]`。
- 释放内存：首先释放最内层的数组，然后逐级向外释放。
我们通过理解和掌握双指针和三指针的概念及使用方法，可以有效地处理C++中的复杂数据结构和多级动态内存分配。当然也可以更加灵活的设计出一些复杂的数据结构和算法，方便我们的技能提升。但关键点都在于内存的管理和对指针的操作及修改。
1371
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
