[C++指针] 二维指针的妙用——使用二维指针存元素

绝地灬酷狼 2022-10-10 12:32 137阅读 0赞

最近在看assimp的源码，发现assimp的aiScene存的是`aiMesh**`，而不是`aiMesh*`。

思考了以下，发现这是一个不错的做法，分享出来。

#include<iostream>
    
    using namespace std;
    
    //主题：新增元素
    
    //方案一：使用一维指针
    void test1()
    { 
    	auto _print = [](int *p, int size)
    	{ 
    		for (int i = 0; i < size; ++i)
    		{ 
    			cout << p[i] << '\t';
    		}
    
    		cout << endl;
    	};
    
    	//保存元素
    	int size = 0;		//元素个数
    	int *p = nullptr;	//使用一维指针，保存元素
    
    	第一次，扫描到5个元素，要将它们收集起来
    	{ 
    		size = 5;
    		p = new int[size];
    
    		for (int i = 0; i < size; ++i)
    		{ 
    			p[i] = i;
    		}
    
    		_print(p, size);
    	}
    	
    	第二次，扫描到3个元素，要将它们收集起来
    	{ 
    		int addedSize = 3;
    		int *tmp = new int[size + addedSize]; //新开辟一个空间，申请能容纳所有元素的空间大小
    
    		//拷贝原来的数值
    		memcpy(tmp, p, size * sizeof(int));
    		_print(tmp, size + addedSize);
    
    		//新数值
    		for (int i = size; i < size + addedSize; ++i)
    		{ 
    			tmp[i] = i;
    		}
    
    		delete[] p;
    		p = tmp;
    		size = size + addedSize;
    		_print(p, size);
    	}
    	
    	//收尾
    	delete[] p;
    }
    //缺点：
    //1.新增元素的时候，需要扩容。而扩容时，需要申请比原来还多的空间。如果元素类型不是int，而是一个类，在扩容时，新开辟的内存会很大
    //2.扩容时，需要拷贝原来的元素，如果元素类型是一个很复杂类，拷贝是一个很麻烦的事情
    
    //使用二维指针
    void test2()
    { 
    	auto _print = [](int **p, int size)
    	{ 
    		for (int i = 0; i < size; ++i)
    		{ 
    			cout << p[i][0] << '\t';
    		}
    
    		cout << endl;
    	};
    
    	//保存元素
    	int **p = nullptr;
    	int size = 0; //当前p的元素个数
    
    	//第一次，扫描到5个元素，要将它们收集起来
    	{ 
    		//创建5个一维指针
    		p = new int*[5] {  nullptr };
    		size = 5;
    
    		for (int i = 0; i < size; ++i)
    		{ 
    			//创建元素
    			int* element = new int{ i};
    			p[i] = element;
    		}
    
    		_print(p, size);
    	}
    	//即创建了一个5x1的矩阵，用于存这个5个元素
    
    	//第二次，扫描到3个元素，要将它们收集起来
    	{ 
    		int addedSize = 3;
    		int** tmp = new int*[size + addedSize] {  nullptr };
    
    		//赋值原来的元素
    		for (int i = 0; i < size; ++i)
    		{ 
    			tmp[i] = p[i];
    		}
    		_print(tmp, size);
    		
    		//新元素
    		for (int i = size; i < size + addedSize; ++i)
    		{ 
    			int* element = new int{  i };
    			tmp[i] = element;
    		}
    
    		delete[] p;
    		p = tmp;
    		size = size + addedSize;
    		_print(p, size);
    	}
    	
    	//回收
    	for (int i = 0; i < size; ++i)
    	{ 
    		delete p[i];
    	}
    
    	delete[] p;
    }
    //可以看到，二维指针也实现了效果
    //1. 在扩容时，申请的大小只是 指针*个数，不用申请 元素*个数。如此，在峰值时，对内存的压力不会太大
    //2. 避免了拷贝操作
    
    int main()
    { 
    	test1();
    	cout << endl;
    
    	test2();
    
    	return 0;
    }