c ++类返回指向要用作数组的成员的指针

Question

class vector3
{
private:
    float x;
    float y;
    float z;
public:
    vector3( float x, float y, float z ) : x(x), y(y), z(z) {}
    // returning pointer to first member to use it as array.
    // assumes that data layout is sizeof(float) by sizeof(float) by sizeof(float)
    // and their order is not changed.
    float* ptr() { return &x; }
    // implicit casting version of ptr()
    operator float*() { return ptr(); }

};

...

vector3 v(1,2,3);
float x = v[0];
float y = v[1];
float z = v[2];

Will it be valid on any platform and any compiler setting? I found this working under visual studio 2013 correctly, but I'm having a feeling that this is quite horribly wrong.

Answer 1

As a general rule you should prohibit yourself from returning pointer/non-const references of your private data members.

Essential purpose of encapsulation is that state of object ( ie data members ) can only be changed through member functions defined for that class.By returning pointers to data member you are creating another path for changing state which is definitely not a good idea.

If efficiency is the main concern then you can return const references.

Answer 2

Your feeling is correct.

But what's the point? Why you don't you just have an array member rather than 3 individual float members?

class vector3
{
private:
    std::array<float, 3> data;
public:
    vector3( float x, float y, float z ) : data( {x, y, z } ) {}
    float* ptr() { return data.data(); }
    operator float*() { return ptr(); }
};

This uses C++11, but you can achieve the same thing with C++03:

class vector3
{
private:
    float data[3];
public:
    vector3( float x, float y, float z )
    {
        data[0] = x;
        data[1] = y;
        data[2] = z;
    }
    float* ptr() { return data; }
    operator float*() { return ptr(); }
};

And of course, the biggest question is: Why don't you just use std::vector or std::array directly? Your class seems to reinvent the wheel.