取消引用指向类内对象的指针

Dereferencing a pointer to an object inside its class

本文关键字：对象 指针 引用 取消      更新时间：2023-10-16

我已经将SquareMatrix定义为这样的

SquareMatrix.h

#ifndef SQUAREMATRIX_H
#define SQUAREMATRIX_H
#include "Matrix.h"
#include <vector>
class SquareMatrix : public Matrix
{
    public:
        SquareMatrix();
        SquareMatrix(std::vector<std::vector<long double> >);
        //~SquareMatrix();    //just in case there is dynamic memory explicitly used
        //convenient member functions exclusive to SquareMatrix
        bool isUpperDiagonalMatrix() const;
        static SquareMatrix identityMatrix(unsigned);
        void LUDecompose();
        SquareMatrix *Lptr, *Uptr, *Pptr; //should be initialized by LUDecompose before using
    protected:
        void validateData();
    private:
};
#endif // SQUAREMATRIX_H

并且我正试图通过对SquareMatrix::LUDecompose()的调用来设置Lptr、Uptr（以及可能的Pptr）。其定义如下：

void SquareMatrix::LUDecompose()
{
    unsigned rowCount = this->getRowCount();
    //initialize L to identityMatrix
    *this->Lptr = SquareMatrix::identityMatrix(rowCount);
    //initialize U to sparse matrix with the first row containing the sole non-zero elements
    std::vector<std::vector<long double> > UData(1, this->matrixData[0]);   //making first rowVector the first rowVector of this
    UData.insert(UData.end(), rowCount - 1, std::vector<long double>(rowCount,0)); //making all other rowVectors zero vectors
    *Uptr = SquareMatrix(UData);
    // attempting to perform LU decomposition
    for (unsigned j = 0; j < rowCount; j++)
    {
        long double pivot = Uptr->matrixData[j][j];
        //the pivot should be non-zero; throwing exception that should effectively cause function to return
        if (pivot == 0)
            throw MatrixArithmeticException(LU_DECOMPOSITION_FAILURE);
        for (unsigned k = j+1; k < rowCount; k++)
        {
            if (j == 0)
            {
                //using *this to compute entries for L,U
                this->Lptr->matrixData[k][j] = (this->matrixData[k][j])/pivot;   //setting columns of L
                long double multiplier = this->Lptr->matrixData[k][j];
                //setting row of U
                for (unsigned l = k; l < rowCount; l++)
                {
                    Uptr->matrixData[k][l] = (this->matrixData[k][l])-multiplier*(this->matrixData[0][l]);
                }
            }
            else
            {
                //using U to compute entries for L,U
                //same procedure as before
                this->Lptr->matrixData[k][j] = (Uptr->matrixData[k][j])/pivot;
                long double multiplier = this->Lptr->matrixData[k][j];
                for (unsigned l = k; l < rowCount; l++)
                {
                    Uptr->matrixData[k][l] -= multiplier*(Uptr->matrixData[0][l]);
                }
            }
        }
    }
}

在尝试测试这个函数时，它向我抛出了一个分段错误，最后一行是我尝试操作Lptr的第一行。

我试图更改Lptr指向的对象，但我知道我将无法引用该函数并将指针设置为等于该引用。换句话说，我的编译器（GNUGCC编译器）将不允许this->Lptr = &SquareMatrix::identityMatrix(rowCount);，因为它将抛出-fpermission类型错误。

注：SquareMatrix::identityMatrix(unsigned)定义为：

SquareMatrix SquareMatrix::identityMatrix(unsigned size)
{
    std::vector<long double> rowVector(size, 0L);
    std::vector<std::vector<long double> > identityMatrixData;
    for (int i = 0; i < size; i++)
    {
        //setting the rowVector to zero-one vector
        rowVector[i] = 1L;
        if (i > 0) rowVector[i-1] = 0L;
        //pushing rowVector into identityMatrixData
        identityMatrixData.push_back(rowVector);
    }
    return SquareMatrix(identityMatrixData);
}

你认为你能做些什么

我想我有两个选择：

  1. 将对象扔到堆上，然后尝试用函数设置它（这似乎毫无用处，因为您正在通过将其扔到堆上来重新定义刚刚定义的对象）
  2. 得到c++11（或类似的东西）
  3. 使函数成为返回大小为2的std::vector<SquareMatrix*>（包含指向两个所需SquareMatrix值的指针）的辅助函数，并创建一个调用辅助函数并将Lptr、Uptr设置为返回的vector的各个元素的函数

我的选择如此有限吗

LUDecompose()中的*Uptr = SquareMatrix(UData);就是问题所在。当函数返回时，不能将指针设置为要销毁的对象。然后指针就是一个悬空指针，每当你试图使用它时，它就会断开。

你需要做Uptr = new SquareMatrix(UData);。然后在析构函数中，调用delete Uptr;。

如果您有权访问C++11，则可以使用std::unique_ptr或任何指针容器/包装器。

您的选择示例：

#include <memory>
class Matrix
{
    public:
        Matrix() {}
        virtual ~Matrix() {}
};
class SqMatrix : public Matrix  //using raw pointers. You must remember to delete your pointers.
{
    private:
        SqMatrix* UPtr = nullptr;
    public:
        SqMatrix() : Matrix() {}
        void InitPtrs() {delete UPtr; UPtr = new SqMatrix();}
        ~SqMatrix() {delete UPtr;}
};
class OMatrix : public Matrix //No need to worry about clean up.
{
    private:
        std::unique_ptr<OMatrix> OPtr;
    public:
        OMatrix() : Matrix() {}
        void InitPtrs() {OPtr.reset(new OMatrix());}
        ~OMatrix() {}
};

另一种选择是将其存储在向量中。

相关文章：