我可以将类成员变量设置为类函数的结果吗？

Question

I have two functions in a Vector class, x() and y() that return the corresponding component from the vector. I want to be able to access the component using a member variable instead (or as well).

Previously I made x and y pointers that point directly into the array of components, data - but this isn't a good solution because someone could change the pointer, right? And it would need to be dereferenced every time it is used.

I cannot use a union due to how my classes are structured.

Currently my idea is to have the member variables x and y return the result of functions x() and y() . Is this a feasible solution?

template <typename T>
class Vec2 : public VecBase<T, 2>
{
public:
    T& x = x();     //Doesn't work but is what I'm trying to achieve
    T& y = y();

    T& x() const { return data[0]; }
    T& y() const { return data[1]; }
}

EDIT: Should have made it more obvious - VecBase is a variable sized vector (vector2, vector3, etc.). Vec2 adds x and y when the size is 2 to make accessing the components easier. It's hard to show without pasting all the code. Ha.

The outcome I want is to basically be able to access the components of the vector easily like so:

Vec2<int> vector;
vector.x = 20;
vector.y = 40;

The functions x() and y() aren't necessary in the solution.

Thanks for your help!

Answer 1

Your reference member approach can work:

template <typename T>
class Vec2 : public VecBase<T, 2>
{
public:
    Vec2() : x(this->data[0]), y(this->data[1]) {}

    T& x;
    T& y;
};

However, now you have a user-defined constructor. Plus there's still going to be a dereference under the bonnet. Personally I'd avoid this over-complication entirely, if possible.

Although I understand that you want to implement the guts of it all in a generic way, and that your base can't "automatically" name the members in a nice mathsy way, consider whether you really need this. Why not just a couple of Vec2 , Vec3 types that literally just have direct members in them? Do you really need anything more?

Having T as a template parameter is a good idea though.

Answer 2

I want to be able to access the component using a member variable

Then simply use a struct (or class with public members):

template <typename T>
struct Vector
{ 
    T x;
    T y;
};

Vector<int> v;
v.x = 42;
v.y = data[2];

Answer 3

You can achieve almost what you want without the reference members. You can assign to the result of x() .

Vec2<int> vector;
vector.x() = 20;
vector.y() = 40;

Note that you shouldn't allow modifying through a const Vec2 , so overload x and y based on the const qualification.

template <typename T>
class Vec2 : public VecBase<T, 2>
{
public:
    const T& x() const { return data[0]; }
    const T& y() const { return data[1]; }

    T& x() { return data[0]; }
    T& y() { return data[1]; }
};