Return a float array in C++

I currently have a 4x4 matrix class in C++ and I store each value as a 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;
}

My question is, how can I return a float array of this data? I hav开发者_如何学运维e no problem creating the array in the class for example:

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

However I can not return this value from the class. I've read about returning a pointer to the array, but have had no luck with it.

1. Don't pass floats by const reference, pass them by value.

2. I assume you want to return the array so you can do indexing? Then don't return an array from you matrix class. Instead, overload the [] operator or something.

3. Also, I wouldn't use 16 member variables but one array instead. Makes indexing a lot easier.

Here is how I would probably do it:

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;
}

This would work if your internal array looked like float array[4][4]:

float** Matrix4d::getMatrix();

If your internal array was a one-dimensional array:

float* Matrix4d::getMatrix();

But both cases expose the internal workings of your class to the outside world, with makes your code less safe and harder to maintain.

It would be better to create a copy constructor, a () operator, and an assignment operator for your Matrix4d class and just pass that around. You'd be less likely to have runtime errors due to bad memory management or data corruption.

Your () operator would look like this:

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

You would call it like this for setting values:

aMatrix(0,0) = 2.0;

or this for retrieving:

float attributeCopy = aMatrix(0,0);

It works both ways.

EDIT: Forgot that the [] operator only took one argument. Changed the operator to the () operator a.k.a the functional operator.

You can use a union to describe your class.

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

You can then return _m.

also getting cols can be useful so:

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

Three options I can think of.

The first is return a std::vector rather than an array. The user can always get pointer to the internal array by &v[0].

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

The second is return a boost::array. (I think there's a tr1::array from the upcoming C++0x standard if your compiler supports something like that) Again its easy to get to the internal array.

The third is the hackiest but may best if you need speed. If you're storing your floats contiguously you could just return a pointer to the first entry. (Note you need to be careful about the details of your class otherwise you end up with "undefined behaviour". However, many/most/all compilers will still "do the right thing" anyway.) Oh and you need to be careful as the pointer will only be valid while the matrix still exists.

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

Just access the address of the first element.

inline float* asArray {
  return &_m00 ;
}

You can treat any struct as an array.

Matrix4d matrix ;
// init with values..

functionThatExpectsArrayOfFloat( &matrix._m00 ) ;