Question

我目前在C ++中有一个4x4矩阵类，我将每个值存储为float：

Matrix4d::Matrix4d(const float& m00, const float& m01, const float& m02, const float& m03,
                   const float& m10, const float& m11, const float& m12, const float& m13,
                   const float& m20, const float& m21, const float& m22, const float& m23,
                   const float& m30, const float& m31, const float& m32, const float& m33)
{
    _m00 = m00;
    _m01 = m01;
    _m02 = m02;
    _m03 = m03;
    _m10 = m10;
    _m11 = m11;
    _m12 = m12;
    _m13 = m13;
    _m20 = m20;
    _m21 = m21;
    _m22 = m22;
    _m23 = m23;
    _m30 = m30;
    _m31 = m31;
    _m32 = m32;
    _m33 = m33;
}

我的问题是，如何返回此数据的float数组？我在类中创建数组没有问题，例如：

float arrayToReturn[16] = { m00, m01, m02, m03, ... m33 };

但是我不能从课堂上返回这个值。我已经读过关于返回指向数组的指针，但是没有运气。

Answer 1

不要通过const引用传递浮点数，按值传递它们。
我假设您要返回数组，以便进行索引编制？然后不要从矩阵类返回一个数组。相反，重载[]运算符或其他内容。
另外，我不会使用16个成员变量而是使用一个数组。使索引更容易。

我可能会这样做：

class Matrix4d
{
    float matrix[4][4];

public:

    Matrix4d(float m00, float m01, float m02, float m03,
             float m10, float m11, float m12, float m13,
             float m20, float m21, float m22, float m23,
             float m30, float m31, float m32, float m33)
    {
        matrix[0][0] = m00;
        matrix[0][1] = m01;
        matrix[0][2] = m02;
        matrix[0][3] = m03;
        matrix[1][0] = m10;
        matrix[1][1] = m11;
        matrix[1][2] = m12;
        matrix[1][3] = m13;
        matrix[2][0] = m20;
        matrix[2][1] = m21;
        matrix[2][2] = m22;
        matrix[2][3] = m23;
        matrix[3][0] = m30;
        matrix[3][1] = m31;
        matrix[3][2] = m32;
        matrix[3][3] = m33;
    }

    float* operator[](int i)
    {
        return matrix[i];
    }

    const float* operator[](int i) const
    {
        return matrix[i];
    }
};

int main()
{
    Matrix4d test(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17, 16);
    test[3][2] = 15;
}

Answer 2

如果您的内部数组看起来像float array[4][4]：

，这将有效

float** Matrix4d::getMatrix();

如果您的内部数组是一维数组：

float* Matrix4d::getMatrix();

但是这两种情况都会将你班级的内部工作暴露给外界，使你的代码更安全，更难维护。

最好为Matrix4d类创建一个复制构造函数，一个()运算符和赋值运算符，然后传递它。由于内存管理不良或数据损坏，您不太可能遇到运行时错误。

您的()运算符如下所示：

float& operator()( unsigned int xIndex, unsigned int yIndex )
{
  //return the right attribute
}

您可以这样设置值：

aMatrix(0,0) = 2.0;

或者这个用于检索：

float attributeCopy = aMatrix(0,0);

它有两种方式。

编辑：忘了[]运算符只接了一个参数。将运算符更改为()运算符a.k.a函数运算符。

Answer 3

您可以使用联合来描述您的班级。

union
{
    struct
    {
       float _m00;
       float _m01;
       ...
    };
    float _m[16];
};

然后您可以返回_m。

获得cols也很有用：

union
{
    struct
    {
       float _m00;
       float _m01;
       ...
    };
    float _m[4*4];
    float _cols[4][4];
};

Answer 4

我能想到三个选项。

第一个是返回一个std :: vector而不是一个数组。用户总是可以通过＆amp; v [0]获得指向内部数组的指针。

std::vector<float> Matric4d::getData() { 
  std::vector<float> d(16); 
  d[0]=_m00; 
  ... 
  return d;
}

第二个是返回一个boost :: array。（我认为如果您的编译器支持类似的东西，那么即将推出的C ++ 0x标准中有一个tr1 :: array）同样很容易进入内部数组。

第三个是最讨厌的但如果你需要速度可能是最好的。如果你连续存储你的花车，你可以只返回指向第一个条目的指针。（注意你需要小心你的类的细节，否则你最终会得到“未定义的行为”。但是，无论如何，许多/大多数/所有编译器仍然会“做正确的事情”。）哦，你需要小心，只有在矩阵仍然存在时，指针才有效。

float * Matrix4d::getData() { return &_m00; }

Answer 5

只需访问第一个元素的地址。

inline float* asArray {
  return &_m00 ;
}

您可以对待any struct as an array。

Matrix4d matrix ;
// init with values..

functionThatExpectsArrayOfFloat( &matrix._m00 ) ;

在C ++中返回一个float数组

5 个答案: