Question

C++ , 动态指针数组作为类的成员，如何分配空间

C++ 类中，有一个成员是动态指针数组，TYPE** arr; int size;
数组 arr[size] 里德元素是指向TYPE的指针TYPE*。size是个变量。

怎么初始化这个成员，关键是怎么给它分配空间？还有怎么delete 它产生的资源。

是不是
for(int k =0; k < size; k++)
{
arr[k] = new TYPE;
}
arr = new TYPE*[size];

delete 的时候就是先循环delete arr[k];再delete arr;
to dongyue2008 :
我这样做，但是在应用时给arr[k赋值时为出现读取错误。

是不是空间分配有问题？

to shark_8309 :
实现的时候我是放在前面的。

分配空间时，关键是size的默认初始化是一个很大的数。
而如果size初始化为0 的话，之后的[k]分配又会有问题。
在另一个类中调用时会出现“out of memory ”，分配内存过多的问题。

Answer 1

dongyue2008的程序没错呀。
问题是不是在这里，你的程序：
for(int k =0; k < size; k++)
{
arr[k] = new TYPE;
}
arr = new TYPE*[size]; //这个是应该放在前面的
把两个部分写反了，结果arr被赋值到一个新的地址，内容是三个不确定的int指针地址，于是赋值的时候就出错了

Answer 2

在构造函数中分配空间：
arr = new TYPE*[size];
for(int k=0; k<size;k++)
arr[k] = new TYPE;
在析构函数中回收资源：
for(int k=0;k<size; k++)
delete arr[k];
delete []arr;

再来一个示例：
#include <iostream>
using namespace std;
int main()
{
int ** arr;
arr = new int* [3];
for (int k=0; k<3; k++)
{
arr[k] = new int;
cin>>*arr[k];
}
for (int k=0; k<3; k++)
cout<<*arr[k]<<" ";
cout<<endl;

for (int k=0; k<3; k++)
delete arr[k];
delete []arr;

return 0;
}

Answer 3

　　采用逐级分配的方式进行分配，从顶级开始分配，再分配子级

　　释放的时候采用逐级释放，从子级开始释放，再释放顶级

　　示例代码如下：

class test{
public :
    int size;
    TYPE** attr;
    test(){
        size=0;
        attr=NULL;
    }
    ~test(){
        if(size>0 && attr != NULL)
        {
            for(int i=0;i<size;i++){//先遍历子级，释放子级内存
                delete attr[i];
                attr[i] = NULL;
            }
            delete[]attr;//释放顶级内存
            attr = NULL;
            size = 0;
        }
    }
    void alloc(int k){
        attr = new TYPE*[k];//先分配顶级内存
        for(int i=0;i<k;i++){
            attr[i] = new TYPE;//再分配子级内存
        }
        size = k;
    }
}

　　多维数组内存分配可以采用逐级分配的方式，自顶向下进行

　　多维数组析构内存可以采用逐级析构的方式，自底向上进行

Answer 4

1. C++中的数组一旦声明，就是固定长度的。所以你可以用int i_arr[256];这样的写法来作为类的成员。

2. 如果你的数组要是“动态”的，也就是在类对象运行期变化长度，建议你使用stl的vector等容器。

3. 如果你不想使用容器，你也可以定义一个int* ptr_i_arr;使用一个指针来记录你在堆中的new的数组的首地址。

方案2，容器的数据是放在堆上的，但是容器对象会自动在析构时释放所占用的空间。

方案3，其数组内容实际上都放在堆上，而不会被包含在类对象内部，因此也不会被自动的释放，你需要在析构器里手动释放。

如果你的动态数组不是元素非常多（好几万），建议使用方案2，代码简洁且容易维护。

如果你的动态数组有一个不大的逻辑上限，可以使用方案1，另外加一个count成员记录数组长度即可。

Answer 5

TYPE** p=new TYPE*[size];
for(int i=0;i<size;i++)
{
p[i]=new TYPE;
}
// delete
for(int j=0;j<size;j++)
{
delete p[j];
}
delete[] p;
关键理解点: TYPE* 等同于一个类型，就像TYPE一样使用，