Converting base class pointer to derived class pointer

Question

As shown in the following code i am trying to convert a base class pointer to derived class pointer. I am expecting compiler error from the following code but does not report any error. Also the function "SomeMethod_2" printing value 10.

#include <iostream>

using namespace std;

class Base {
public:
    Base() {
        cout << "Base class constructor\n";
    }

};

class Derived : public Base
{
public:
    int Val;
    Derived() {
        cout << "Derived class constructor\n";
    }
    void SomeMethod(void)
    {
        cout << "SomeMethod\n";

    }
    void SomeMethod_1(void)
    {
        Val = 10;
    }
    void SomeMethod_2(void)
    {
        cout << Val;
    }
};


int main()
{
    Base* BaseObj = new Base();

    Derived* DerivedObj = (Derived*) BaseObj;

    DerivedObj->SomeMethod();    # Expecting compiler error
    DerivedObj->SomeMethod_1();
    DerivedObj->SomeMethod_2();
    return 0;
}

No, the compiler doesn't catch undefined behavior with errors. BTW, you could check the correctness with a dynamic_cast<Derived*> at runtime. — πάντα ῥεῖ
– πάντα ῥεῖ, Commented Jun 27, 2019 at 16:18
@oblivion I can't see why. There's no slicing in this whatsoever, just blatant casting leading to later undefined behavior. — WhozCraig
– WhozCraig, Commented Jun 27, 2019 at 16:23
(Derived*)BaseObj is a c-style cast and sloppy speaking it tells the compiler: "I am more clever than you, do not bother me with warnings or errors". Don't use it when you want the compiler to help you with warnings / errors — 463035818_is_not_an_ai
– 463035818_is_not_an_ai, Commented Jun 27, 2019 at 16:26

aschepler · Accepted Answer · 2019-06-27 16:29:03Z

A cast, especially a C-style cast, tells the compiler to shut up about many errors and warnings, and that you promise you know what you're doing, at your own risk.

Using a pointer which does not point at an object of that type is in most cases Undefined Behavior. Undefined Behavior is just that - there are no requirements about what could happen, so you MIGHT get a compiler error or runtime error. Or you might have it seem to "work" (whatever that might mean), or something entirely unexpected.

As far as what's actually going on in your particular case, the functions are most likely using adjacent memory that does not belong to *BaseObj to store the int, but this happened not to matter afterward. If you had remembered to delete the object, though, there's a chance you would run into a problem at that point, since the overwritten memory may have been used by the heap memory management functions.

Note that if Base had at least one virtual function (like the destructor), and if you used the safer dynamic_cast instead of the least safe C-style cast, then the result of the cast would be a null pointer, since dynamic_cast does a check for whether the object actually is of that type.

class Base {
public:
    Base() {
        cout << "Base class constructor\n";
    }
    virtual ~Base() = default;
};

// ...

int main()
{
    Base* BaseObj = new Base();

    Derived* DerivedObj = dynamic_cast<Derived*>(BaseObj);

    if (DerivedObj) {
        DerivedObj->SomeMethod();
        DerivedObj->SomeMethod_1();
        DerivedObj->SomeMethod_2();
    } else {
        std::cout << "Not a Derived\n";
    }

    delete BaseObj; // Don't forget to match every "new" with a "delete".
    return 0;
}

Community · Accepted Answer · 2020-06-20 09:12:55Z

1

Derived* DerivedObj ....
DerivedObj->SomeMethod();    # Expecting compiler error

I am expecting compiler error

There's no reason to expect a compiler error here. DerivedObj is a pointer to Derived which has a member function SomeMethod and therefore the function call is well-formed, and compiler is required to succesfully compile it.

Now, whether the behaviour of indirecting through the pointer DerivedObj and calling a member function is well defined depends on whether the pointer is valid. It is not valid in this case, and therefore the behaviour of the program is undefined.

Also the function "SomeMethod_2" printing value 10.

This is an example of undefined behaviour.

edited Jun 20, 2020 at 9:12

CommunityBot

11 silver badge

answered Jun 27, 2019 at 16:38

eerorika

240k13 gold badges212 silver badges354 bronze badges

Comments

Boki · Accepted Answer · 2019-06-27 16:54:59Z

1

You have just executed c-style cast of Base* to Derived*. Function SomeMethod is defined in Derived class and as such its call is legal through Derived*, not an compile time error. Member functions are not part of class instance, but rather they've placed in code segment and member functions invocation for particular instance is possible with hidden this argument. If you have no data members there are even no slicing happened. It is always good idea, after pointer casting to check if what it is cast to, represent an valid pointer. And of course, in c++ we use dynamic_cast for use case like this.

edited Jun 27, 2019 at 16:54

answered Jun 27, 2019 at 16:36

Boki

6653 silver badges12 bronze badges

Collectives™ on Stack Overflow

Converting base class pointer to derived class pointer

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related