我是否误解了指针的工作原理？

Question

我有一个类 Matrix 和另一个类 Camera，我想在其中使用 Matrix。我的 Matrix 类如下所示：

class Matrix4f {
    public:
        Matrix4f() {
            this->setMatrix(EMPTY);
        }

        Matrix4f(Matrix4f &m2) {
            this->setMatrix(m2.matrix);
        }

        static Matrix4f& Matrix4f::identity() {
           Matrix4f& identity = Matrix4f() ;
           identity.setMatrix(IDENTITY);
           return identity;
        }

        void setMatrix(float f[4][4]) {
            for (int r = 0; r < 4; r++) {
                 for (int c = 0; c < 4; c++) {
                      this->matrix[r][c] = f[r][c];
                 }
            }
        }

        Matrix4f& operator=(const Matrix4f &m2) {
             this->setMatrix(m2.matrix);
        }
    private:
        float matrix[4][4];
        static float EMPTY[4][4] = {
             { 0, 0, 0, 0 },
             { 0, 0, 0, 0 },
             { 0, 0, 0, 0 },
             { 0, 0, 0, 0 }
        }; // initialize an empty array (all zeros);
        static float IDENTIY[4][4] = {
             { 1, 0, 0, 0 },
             { 0, 1, 0, 0 },
             { 0, 0, 1, 0 },
             { 0, 0, 0, 1 }
        }; // initialize a identity (array)
}

我的相机课上有这个：

class Camera {
    public:
        Camera() {
            this->calculateProjection();
        }

        Matrix4f* getProjection() {
            return this->projection;
        }
    private:
        Matrix4f* projection;

        Matrix4f* calculateProjection() {
             this->projection = &Matrix4f::identity();
             // modify this->projection...

             return this->projection;
        }
  }

当我尝试创建一个 Camera 实例然后获取它的投影时，我得到的东西看起来像是一个损坏的对象（矩阵完全填充为大的负数）。

我真的很困惑是什么原因造成的我的代码会像这样行为不端。
我相当肯定它处理的是编译器自动删除的引用，我认为它处理的是单位矩阵，但它并没有真正的意义。

不应该将单位矩阵复制到投影矩阵中，这样单位矩阵是否被垃圾收集也没有关系？

我发现我实际上可以通过以下任一方式使这段代码工作 使单位矩阵创建一个新的 Matrix4f() 并返回该值或使 getProjection() 返回 calculateProjection()。
问题是，我真的不想做任何一个。
我不希望 Identity 构造一个新的 Matrix4f，因为我必须处理破坏它，而且我不想要 getProjection( ) 来调用 calculateProjection() 因为该方法很昂贵，
实际上应该只调用一次，因为投影矩阵永远不会改变。

Answer 1

你的

 Matrix4f& Matrix4f::identity() {
           Matrix4f& identity = Matrix4f() ;
           identity.setMatrix(IDENTITY);
           return identity;
        }

返回对本地对象的引用。一旦 identity() 退出，对象就消失了。

你需要在堆上分配它然后返回它。

或者在你的相机类中声明一个矩阵

  ...
  private:
    Matrix4f projection;

    Matrix4f& calculateProjection() { 
         ... modify ...
         return this->projection;
    }
   ...

Answer 2

我是否误解了指针的工作原理？

也许吧。您的代码有几个我可以看到的问题：

    Matrix4f& Matrix4f::identity() {
       Matrix4f& identity = Matrix4f() ;
       identity.setMatrix(IDENTITY);
       return identity;
    }

这会创建一个临时对象和一个对它的引用（该引用称为identity）。我不确定临时对象是否在Matrix4f& identity = Matrix4f() ; 之后被销毁，或者在函数返回时被销毁 - 但无论哪种方式，临时对象在函数返回之前被销毁，因此函数返回对已被销毁对象的引用。

this->projection = &Matrix4f::identity();

this->projection 然后设置为被销毁的临时对象的地址。

稍后，您尝试访问已被销毁的临时对象，不出所料地得到垃圾数据。

另外，identity（函数）不是静态的，因此您不能将其称为Matrix4f::identity()。