Array of derived objects to array of base objects

Question

There are multiple questions pretty similiar to this one with the difference that there sizeof(Base) != sizeof(Derived). That won't work for obvious reasons (the subscript operator applied on the pointer is relative to the pointees size, not to the actual unterlying type). However, I was wondering whether this code would be correct or not:

struct Base
{
    int Data;
};
struct Derived : public Base
{
};
int main()
{
    static_assert(sizeof(Base) == sizeof(Derived), "Sizes are not equal");

    Derived Data[10];
    Base* Ptr = Data;
    Ptr[3].Data = 5;
}

Obviously, Ptr[3] won't access any half ripped Base instances anymore since the sizes are equal, but is the code still correct?

The language does not guarantee that the sizes are equal. If you guarantee that, then yes, it looks legal (doesn't mean you should). — n. m. could be an AI
– n. m. could be an AI, Commented Oct 23, 2014 at 13:38

Mike Seymour · Accepted Answer · 2014-10-23 12:56:24Z

1

Yes, this is correct (in the sense of well-defined, not necessarily sane) since the two classes are layout-compatible - they are standard-layout structs with the same non-static data members.

It's very fragile though; small changes to the classes could break the compatibility and give undefined behaviour.

answered Oct 23, 2014 at 12:56

Mike Seymour

256k30 gold badges467 silver badges658 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Fytch Over a year ago

Is it still well-defined if Base has some virtual methods that Derived overrides (with the size still staying the same)?

Mike Seymour Over a year ago

@Conclusio: no, if a class has virtual functions then it isn't standard layout.

Andrew Stein · Accepted Answer · 2014-10-23 12:59:02Z

1

Let's suppose we have a function that receives a Derived

double foo(Derived d);

Now consider a slight variation of your code:

Derived Data[10];
Base* Ptr = Data;
Base myB;
Ptr[3] = myB;

Essentially we have put a Base object into the Data array. We then call

foo(Data[3]);

Lo and behold we have tricked foo into receiving a Base

This is the reason you should not treat an array of Derived as an array of Base. It is not only the issue of size.

edited Oct 23, 2014 at 12:59

answered Oct 23, 2014 at 12:52

Andrew Stein

13.2k5 gold badges39 silver badges44 bronze badges

1 Comment

n. m. could be an AI Over a year ago

This has nothing to do with arrays. You can do the same if you replace Data with a single Derived object.

score 0 · Accepted Answer · 2014-10-23 12:33:37Z

0

Lets consider following lines:

Derived Data[10];
Base* Ptr = Data;

Data holds an address of first element of array. So, it is a pointer of type Derived*. There is a static cast from Derived* to Base*. That means that code is correct.

edited Oct 23, 2014 at 12:33

answered Oct 23, 2014 at 12:27

user2556165

1 Comment

Fytch Over a year ago

Yes, that's obviously correct and I know that. But that wasn't the question, the core of the question was whether the subsequent subscript operator applied on the pointer is correct or not.

Ali Kazmi · Accepted Answer · 2014-10-23 12:37:50Z

0

this is correct but not generally done because when pointer of derived class points to object of base, there is chance of data corruption.

edited Oct 23, 2014 at 12:37

answered Oct 23, 2014 at 12:31

Ali Kazmi

1,45810 silver badges22 bronze badges

1 Comment

user2556165 Over a year ago

But it is still correct. Anything else does not matter here :)

Collectives™ on Stack Overflow

Array of derived objects to array of base objects

4 Answers 4

2 Comments

1 Comment

1 Comment

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

2 Comments

1 Comment

1 Comment

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related