Reference types and Inheritance issues

Question

How come my compiler does not give me a warning or an error for this code:

class A {};
class B : public A{};
class C : public A{};
int main(int argc,char** args)
{
    B b;
    A& a = b;
    C c;
    a = c;
}

I would tend to think that this would result in the data being stored in the "b" variable is no longer of type "B" and is going to give me a bunch of problems....so why am I able to do this.

score 1 · Accepted Answer · edited Apr 13 '17 at 12:40

1

a = c; performs assignment between the A part of b, and the A part of c. The B and C parts (if any) of those objects are unmodified.

In general this is kind of dangerous as the B and C objects may not have been designed to have only their A sub-object assigned. On this thread are various other suggestions for handling operator= in a class hierarchy.

edited Apr 13 '17 at 12:40

Community

1
1

answered Apr 05 '16 at 23:24

M.M

138,810
21
208
365

So in other words my "b" variable is safe, but my "a" variable won't really act like I would expect it to? – DarthRubik Apr 05 '16 at 23:27
1

@DarthRubik well I'm not sure how you expect the `a` to act – M.M Apr 05 '16 at 23:31

score 1 · Answer 2 · answered Apr 05 '16 at 23:30

See comments:

class A {};
class B : public A{};
class C : public A{};
int main(int argc,char** args)
{
    B b; // memory allocated for b to contain A+B
    A& a = b; // a is referencing A part of A+B
    C c; // memory allocated for c to contain A+C
    a = c; // a (A part of A+B) is overwritten from A part of A+C, c is sliced into a
}

Hope that helps.

score 1 · Answer 3 · edited May 23 '17 at 12:25

How come my compiler does not give me a warning or an error?

A class has a copy constructor and assignment operator by default if they were not declared explicitly. As a result, an instance of derived class (C) can be assigned to a variable of the base class type (A). This effect is known as slicing.

To prevent from this you can disable copy constructor and assignment operator in the base class:

class A 
{
   protected:
     A() = default;
     A(const A & source) = delete;
     A & operator = (const A & source) = delete;
};

 class B : public A{};
 class C : public A{};


 int main(int argc,char** args)
 {
    B b;
    A& a = b;
    C c;
    a = c;  // this will not compile
}

Reference types and Inheritance issues

3 Answers3