目录
摘要
双指针（Double Pointers）
含义
使用场景
三指针（Triple Pointers）
含义
使用场景
总结
双指针的详细说明
三指针的详细说明
摘要
在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; // 输出应该是 10delete 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++中的复杂数据结构和多级动态内存分配。当然也可以更加灵活的设计出一些复杂的数据结构和算法，方便我们的技能提升。但关键点都在于内存的管理和对指针的操作及修改。