C++ static_cast downcast validity

Question

Is this static_cast downcast valid?

// non-virtual, may be non-trivially copyable
struct Base{
    int m_object;
};

// Derived class have only non-virtual functions
struct A : Base{
    void arggh(){
        std::cout << "Arrghh " << m_object;
    }
};

int main() {
    Base base{190};
    A& a = static_cast<A&>(base);
    a.arggh();
    return 0;
}

I mean, CREATE base class, and then cast to derived.

Live

You should do the invert Base* b = new A(); and all the methods that you have that are common should be "virtual". That is how you handle it, that is the reason to have a interface that specifies the contract. — Lefsler, Nov 15 '17 at 15:14
@miradham Wel...... I found myself in situation where I start writing Proxy object, which I could easily recreate(it have only 1 ptr). Then I need Proxy + some data... And then I thought what a heck... :) Hard to explain in two words. — tower120, Nov 15 '17 at 15:19

score 11 · Accepted Answer · edited Nov 23 '17 at 12:36

static_cast for performing downcast does not perform any safety checks. Since it's possible for a Base& to be referencing an instance of A, the cast proceeds and since it's NOT actually referencing an A, we enter undefined behavior territory^*.

A dynamic_cast on the other hand is safer. It will perform a check and throw an exception in the case of reference casting, or return nullptr in the case of pointer casting^†.

However, since your base class lacks any virtual functions, dynamic_cast is impossible, so you'd need to modify it with at least a virtual destructor:

class Base{
public:
    int m_object;
    virtual ~Base()=default;
};

Now if we tried to cast:

A* a = dynamic_cast<A*>(&base);
if (a)
    a->arggh();
else
    std::cout << "null\n";

Our output would be

null

^*Relevant standardese can be found in [expr.static.cast]:

[for a cast like static_cast<D&>(b) where b is an instance of a base class for D], If the object of type “cv1 B” is actually a base class subobject of an object of type D, the result refers to the enclosing object of type D. Otherwise, the behavior is undefined.

^†Relevant standardese at [expr.dynamic.cast]

The value of a failed cast to pointer type is the null pointer value of the required result type. A failed cast to reference type throws an exception of a type that would match a handler of type std::bad_cast

Note that adding virtual member function and performing a dynamic_cast has a performance cost. — Guillaume Racicot, Nov 15 '17 at 15:36

score 1 · Answer 2 · answered Nov 15 '17 at 15:06

1

No.

Not all Base objects are of type A¹, although the converse is true, and a static_cast would work in that direction.

¹Another translation unit might have a class that inherits from Base.

answered Nov 15 '17 at 15:06

Bathsheba

231,907
34
361
483

But derived classes "empty", zero-sized, non-virtual http://coliru.stacked-crooked.com/a/ea14a7cd238064e1 – tower120 Nov 15 '17 at 15:08
@tower120: That's UB. – Bathsheba Nov 15 '17 at 15:09
2

@tower120 congratulations, you hit the worst kind of UB: "But it works right now on ths machine on this invocation of the program!" one. – Revolver_Ocelot Nov 15 '17 at 15:09
@Revolver_Ocelot I actually think it will works everywhere now (it have zero offsets)... But UB is UB. – tower120 Nov 15 '17 at 15:12

score 0 · Answer 3 · answered Nov 15 '17 at 15:16

Not at all.

Let's say Base is represented in memory by this block [--] and A is [--+], here you can see that A contains a part Base (with the little '-').

When you are creating a Base you have your [--] and then you are casting it to A which means that you are saying it's in fact [--+] BUT the memory after [--] does not correspond to [--+]

As you may understand with this example, you can cast A to Base because [--+] contains [--]

C++ static_cast downcast validity

3 Answers3

Linked