有没有办法在没有括号的情况下在 C++ 中调用成员的 getter/setter？

Question

I want to run some GLSL code as a C++ code, by #including it in a C++ application, without modification. It has no special pragmas and so on, but it has some vector types. For example vec3 and vec4 , that simply means tuple of 3 and 4 floats, respectively, that is contig in memory and convenient for some linear algebra tasks.

Pretty everything could be done with operator overloading, except one thing. Consider that vec4 a has 4 float members: ax , ay , az and aw ;

In glsl, there is a popular notation a.xyz , that means "take ax,ay,az and construct vec3 from them."

Some languages, like Object oriented versions of Pascal(Delphi) has such facility: such members are defined with property keyword in there. So when compiler meets it, it calls getter, when it meets assigment - it calls setter, and everything looks like you are reading or writing a regular member variable.

How can we write so in C++?

---

class vec4 {
public:
    float x,y,z,w;
    property xyz read=get_xyz write=set_xyz; // ??? is there some way?
protected:
    vec3 get_xyz() const { return vec3(x, y, z); }
    void set_xyz(const vec3& v) { x = v.x; y=v.y; z=v.z; }
};

In code then I want to write getter like this:

vec4 a(1,2,3,4);
auto b = a.xyz; // b = a.get_xyz();

b now is of type vec3 and has x==1 , y==2 , z==3 ;

And setter like this:

vec4 a(1,2,3,4);
a.xyz=vec3(5,6,7); // a.set_xyz(vec3(5,6,7));

a now has x==5 , y==6 , z==7 and w==1 ;

---

How could I support such syntax?

Answer 1

It's a sad fact, that such a mature, powerful and widely-used C++ language has no property support. Even Delphi has.. Luckily, I've managed to solve task (To compile compute glsl shader as C++ without modifying GLSL source). I think it would not have speed/memory penalty, related to creating proxy objects, and would be easily optimizable by compiler (though this is not needed).

I've found following solution:

Try it online!

#include <iostream>

#pragma pack(push, 4)
class vec3 {
public:
    float x,y,z;
    vec3() {}
    vec3(float x, float y, float z) :
        x(x), y(y), z(z)
    {}
};

class vec4 {
public:
    union {
        struct {
            float x, y, z, w;
        };
        vec3 xyz;
    };
    vec4() {}
    vec4(float x, float y, float z, float w):
        x(x), y(y), z(z), w(w)
    {}
};

#pragma pack(pop)

int main() {
    {
        vec4 a(1, 2, 3, 4);
        auto b = a.xyz; // b = a.get_xyz();
        std::cout << b.x << b.y << b.z << std::endl;
    }
    {
        vec4 a(1, 2, 3, 4);
        a.xyz = vec3(5, 6, 7); // a.set_xyz(vec3(5,6,7));
        std::cout << a.x << a.y << a.z << a.w << std::endl;
    }
    return 0;
}