Member in child class a reference to parent member?

Question

Say I have the following test code:

#include <iostream>
using namespace std;

class Vector3 {
public:
    float data[3];
};

class Weird3 : public Vector3 {
public:
    union {
        struct { float &x, &y, &z; };
        struct { float &r, &g, &b; };
    };

    Weird3() : x(Vector3::data[0]), y(Vector3::data[1]), z(Vector3::data[2]) {}

};

int main(int argc, char** argv) {

    const Weird3 w;

    w.x = 100; // Works ok!
    cout << w.x << endl;

    w.data[0] = 100; // Error: assignment of read-only location
    cout << w.x << endl;

    return 0;
}

Why does modifying data member through the reference member in the child class works, but not directly? Also, is there a better way to achieve this behavior? For example, I have a template class VectorN, and derived classes Vector2, Vector3 and Vector4; I would like to modify the data member in VectorN using members in child classes like x,y,z or r,g,b.

While I'm not sure why this code _does_ let you assign `w.x` (guessing due to non-const `float&` assignment on init in child class) I think the reason you can't do `w.data[0] = 100;` is due to `const Weird3 w;` - you shouldn't be modifying a const object. — Xeren Narcy, Jul 24 '15 at 02:51
Yeah, it feels (and it is!) wrong to modify a const object with hacks like these. It would be nice to achieve a similar behavior without breaking the rules like this. — danielrs, Jul 24 '15 at 03:00

score 2 · Accepted Answer · answered Jul 24 '15 at 03:04

Why does modifying data member through the reference member in the child class works, but not directly?

Because you're not modifying the reference. const in C++ isn't logical const, it's more like bitwise const. When you do:

w.x = 100;

You're not actually modifying w.x, so that's allowed. The fact that x happens to refer to a different data member of a const object means this is undefined behavior. But it's perfectly legal code. You just shouldn't do it.

Also, is there a better way to achieve this behavior?

If you want to be able to modify members on a const object, just make them mutable.

I have never used qualifiers like `mutable` or `volatile`. It's great to learn something new! — danielrs, Jul 24 '15 at 03:34

Jack · Answer 2 · 2015-07-24T03:18:04.750

w is declared as const. const does not apply to the referenced member (or pointer in case of a pointer).

This is less clear with a reference since a float& const is not allowed, just because you can't reassign a reference (so you can consider it & const by default).

But with a pointer is clearer to understand:

const float *x

This is a pointer to a constant float. You can't assign a new value to the pointed one by dereferencing it.

float* const y

This is a constant pointer to a float. You can assign a new value to the pointer by dereferencing it, but you can't assign a new value to the pointer (make it point to something else).

Now declaring const Weird3 w makes all the field as not reassignable in w (float* const of the previous example), but you are allowed to modify their values. This means that you aren't actually mutating the state of w but changing something that is referenced or pointed by w.

You have your pointers flipped. `x` is a pointer to constant `float`. — Barry, Jul 24 '15 at 03:09
Nice explanation! Here's a link to anyone interested in `const` pointers and values: http://stackoverflow.com/a/1143272/3932019 — danielrs, Jul 24 '15 at 03:13

score 0 · Answer 3 · answered Jul 24 '15 at 03:05

Why does modifying data member through the reference member in the child class works, but not directly?

Why it does not work directly is pretty obvious, your try to modify const object. Why it does let you modify reference is pretty obvious too - you are not modifying state of the object, but modifying something else, where reference points to. The fact that reference points to const object either itself or something else is not visible here (for compiler) and it could not be, it should only prevent to assign const object to lvalue reference.

So question is why you were able to assign members of const object to lvalue reference. Answer is - constness of the object is not visible in constructor. It may be improved by future changing of the language, but it works this way now.

Anyway modifying const object leads to UB, so your comment "Works ok" is an illusion.

Also, is there a better way to achieve this behavior?

"Better" way is to use const_cast<> directly. It is at least explicit, and can be used to remove constness of objects that are non const originally, but got it through modifications. Again you should not modify const object either through your "hack" nor using C cast nor const_cast<> as it leads to UB.

Member in child class a reference to parent member?

3 Answers3