0

我在为具有私有二维动态数组的模板类创建析构函数时遇到问题。出于某种原因，一旦我将信息输入到矩阵中，析构函数就会破坏矩阵。不知道出了什么问题，因为它编译得很好，但是当我输入前 2 个矩阵的信息并且程序尝试将它们相乘时给出错误。如果我摆脱了析构函数，代码就可以工作。

template <class T>
class matrix
{
//sudo
friend matrix operator + , *,-,(bunch of friends used to overload)
//end sudo 
public:
                matrix(): rows(0), cols(0){}
                int Arows(){return rows;}
                int Acols(){return cols;}
            class Proxy
            {
                matrix& _a;
                int _i;
            public:
                Proxy(matrix& a, int i) : _a(a), _i(i){}
                int& operator[](int j) {return _a.Array[_i][j];};
            };
                Proxy operator[](int i) {return Proxy(*this,i);}
                ~matrix();
                private:
                T ** Array;
                int rows;
                int cols;
                };

                template<class T>
                matrix<T>::~matrix()
            {
                for (int i=0;i<rows;i++)
                    delete [] Array[i];
                delete [] Array;
            }
4

2 回答 2

0

如果没有看到确切的代码和调用代码，很难判断，但这可能是因为您缺少复制构造函数和赋值运算符。

matrix m1;    
{
 matrix m2 = ...
 m1 = m2; // copy ctor, now they share same Array pointer
} // m2 destructor free the Array

// m1 is left with dangling Array pointer

从代码示例来看，它看起来不像真正的代码。Array在哪里初始化，什么是matrixArray？

于 2012-09-12T02:16:33.870 回答
-1

我认为 R. Martinho Fernandes 提供的评论回答了这个问题......我想指出其他一些事情，我只是把它作为一个答案，所以我可以格式化代码。

人们痴迷于做大量的内存分配只是为了制作一个二维数组......但这很慢！如果您对这些矩阵做了很多工作，那么最好进行一次内存分配。它有点像这样：

Array = (T**)malloc( rows*sizeof(T*) + rows*cols*sizeof(T) );
T* rowData = (T*)(Array + rows);
for( int r = 0; r < rows; r++ ) {
    Array[r] = rowData;
    rowData += cols;
}

当你想释放这个内存时：

free((void*)Array);

自然地，我假设您使用的是基本类型......事实上，您最好使用typename T而不是class T在模板中。

哦，是的，这使得将数据从一个矩阵（相同大小）复制到另一个矩阵变得非常容易。您只需按上述方式分配，然后memcpy在数据部分上执行一次。

于 2012-09-12T02:26:02.917 回答