Why the constructor is not called in this case?

[bajajv]

Hi,
I made a class A and a class B. Then created an object of class A using a pointer of A.
Then I gave ->
B* bptr = (B*) aptr;
When I call functions of class B using the bptr, it calls the function.
But during the whole execution, it never calls the constructor of type B.
Then how can it call the function from B class?
What is the mechanism behind this?
How is the variable in class B initialized with some value in class A? And since it is calling functions and initializing variable in class B, it should have constructed an object of this class?? (am I right...?)

class A{
public: 
    int j;
    A() 
    {
        printf("Inside A constructor.\n");
        j=20;
    } 
    ~A() {}
};
 
class B{
public:
    int i;
    int k;
    char c;
    B() {printf("Inside B default constructor.\n");}
    B(A a)
    {
        printf("Inside B constructor.\n"); 
        c='c';
        i = 10; 
        k=100;
    } 
    ~B(){} 
    void fun()
    {
        printf("Inside fun\n");
        printf("i = %d\n", i);
        printf("k = %d\n", k);
    }
};
 
int main()
{
    A* aptr = new A();
    B* bptr = (B*) aptr;
 
    bptr->fun();
 
    return 0;
}
 

[johny10151981]

you never created any object of class B that is why no construction has been called

[Banfa]

You problem is that you are mixing C and C++ code.

You are using printf when you should be using cout and you use a C style cast

    B* bptr = (B*) aptr;
 

The problem with C style casts is that they just work without actually verifying if the cast is sensible and possible. You should avoid using C style casts in favour of one of the C++ casts

static_cast
dynamic_cast
const_cast
reinterpret_cast

Good C++ code has little need to cast so a proliferation of casts in your code would suggest a design flaw.

If you do need to cast then you should be using static_cast as your default using the other ones where you have a good reason to.

dynamic_cast is probably the next most used type used where you can not know the actual type of the object until run-time, you should always check the return value of a dynamic_cast to make sure it is not NULL which it will be if the requested cast was not valid.

const_cast is just for changing the const and volatile specifiers of a type and I have never had cause to use it.

reinterpret_cast is the most dangerous, equivalent to the old C style cast, the compiler just assumes the programmer knows what they are doing and copies the pointer value with no interpretation. I have had call to use this but generally only when dealing with a C API some of which require passing a pointer to object A as a pointer to object B.

In this case you should have used static_cast and if you had done so you would have got the compiler error

error: invalid static_cast from type 'A*' to type 'B*'

That is A* and B* are not compatible types and you can't just copy one to the other.

[bajajv]

Thanks Banfa, your reply was helpfull.

But my doubt is that in the code, I am printing values of variables, which are not static. So, how come I am able to print their values, when I am actually not creating any object?

Because, I think that the non-static variables of a class come into existance only when the object is created.

[Banfa]

It doesn't matter whether you created an object or not, you copied a value into a pointer to type B in a way that circumvents any checks the compiler might usually do.

Like I said at this point the compiler just assumes you know what you are doing, you said "this memory address is the address of an object of type B" and the compiler replied with "OK if you say so" and then the compiler proceeded to act as if that memory location contained an object of type B even though it didn't. B::i is likely to have had the same value as A::j since that memory actually contains an object of type A, B::k and B::c will likely just have random values although actually accessing the would be undefined behaviour since those bits of memory would be outside the bounds on the object of type A that you actually allocated.