Derived class's method without constructor

Question

#include <iostream>
using namespace std;
class Person
{
public:
        void P(){ cout << "Person P" << endl; }
        virtual void Print(){ cout << "Person Print" << endl; }
        Person(){ cout << "Constructor Person" << endl; }
        virtual ~Person(){ cout << "Dectructor Person" << endl; }
};
class Developer : public Person
{
public:
        void Pi() { cout << "Developer Pi" << endl; }
        void Print() override
        {
                cout << "Developer Print" << endl;
        }
        Developer(){ cout << "Constructor Develoeper" << endl; }
        ~Developer(){ cout << "Dectructor Develoer" << endl; }
};
int main()
{
        Person *p = new Person();
        Developer* d = dynamic_cast<Developer*>(p);
        d->Pi();

        delete p;
        delete d;
   return 0;
}

Output:

Constructor Person
Developer Pi
Dectructor Person

Why can I invoke Developer's function Pi?

How can invoke Pi without Developer's Constructor?

Note that Pi is only declared in class Developer.

You can do whatever you want, but it will result in **undefined behavior** — Rakib, May 19 '14 at 15:06
See this very thorough answer for why this is UB: http://stackoverflow.com/a/2474021/3549027 — dlf, May 19 '14 at 15:31

lrineau · Accepted Answer · 2014-05-19T15:14:46.863

3

You cannot. Your code has an undefined behavior. If I modify the main() function to:

int main()
{
    Person *p = new Person();
    Developer* d = dynamic_cast<Developer*>(p);
    assert(d!=0);
    d->Pi();

    delete p;
    delete d;
    return 0;
}

Then the assertion d!=0 is triggered. That shows that the dynamic_cast failed. You call Developer::Pi on a null pointer, and using your compiler it happens to run fine, probably because Developer::Pi does not use this.

edited May 19 '14 at 15:14

answered May 19 '14 at 15:08

lrineau

6,036
3
34
47

1

@irineau, this is not OP's answer. without `assert` the code works and surprisingly calls `Pi`, the question is why – Rakib May 19 '14 at 15:10

Jarod42 · Answer 2 · 2014-05-19T15:39:43.113

2

with Developer* d = dynamic_cast<Developer*>(p);
you have d == nullptr.

with d->Pi(); You invoke undefined behavior:

method are generally equivalent to a function which take extra this as parameter and as you don't use this the method seems to work in your case.

edited May 19 '14 at 15:39

answered May 19 '14 at 15:12

Jarod42

203,559
14
181
302

NeutronCode · Answer 3 · 2014-05-19T15:40:44.890

0

It is becuase of dynamic_cast. You are not referring to any variables in the instance, therefor it does not fail.

Accessing any of the virtual methods or accessing anything that would be stored in the object would give access violation.

edited May 19 '14 at 15:40

answered May 19 '14 at 15:13

NeutronCode

365
2
13

score 0 · Answer 4 · answered May 19 '14 at 15:45

by stating that d is a pointer to an object of the Developer class you give a hint to the compiler. You also declared void Pi() not to be virtual, therefore the compiler used early binding ( compile time ). That means that the address of the function that is invoked is pinned during compilation, and doesn't need an object to be evaluated ( unlike virtual methods )

When calling d->Pi(), it is the same as you'd call Pi(d) with Pi taking a pointer to a Developer instance. In MFC there is a method called Validate or something like that which uses the very same mechanism to check if your pointer isn't null :)

You don't get a crash on delete d because it is in the standard, that deleting a null pointer is OK, and does nothing ( deleting a dirty pointer is undefined tough ).

Just add the word virtual to the Pi method signature OR add a field to Developer class and try to moddify that field in the Pi method. You will then see the difference ;)

Derived class's method without constructor

4 Answers4