When is Downcasting in C Safe, and When Does it Lead to Undefined Behavior?

Downcasting in C : Unveiling the Undefined Behavior

In object-oriented programming, downcasting is a process of converting a pointer or reference of a base class to a pointer or reference of a derived class. In C , this can be achieved using the static_cast operator. However, the consequences of improper downcasting can be perplexing.

Consider the following code snippet:

class base {
public:
    base();
    virtual void func();
};

class derived : public base {
public:
    derived();
    void func();
    void func_d();
    int a;
};

int main() {
    base *b = new base();
    std::cout << sizeof(*b) << std::endl; // Prints 4

    derived *d = static_cast<derived*>(b);
    std::cout << sizeof(*d) << std::endl; // Prints 8

    d->func_d(); // Calls derived class function successfully
}

In this example, a base pointer b is cast to a derived pointer d using static_cast. Surprisingly, d has access to the entire derived object, including the member function func_d(). This raises the question: how is this possible when b only points to a base object?

The answer lies in the undefined behavior introduced by the improper downcasting. According to the C standard, using static_cast to cast a pointer to a type it doesn't genuinely have results in undefined behavior. This means anything can happen, including the correct execution of the derived class function.

The correct approach to downcasting involves using a safe cast operator like dynamic_cast. This operator checks whether the base pointer points to an actual derived object and throws an exception if it doesn't, ensuring proper type safety.

The above is the detailed content of When is Downcasting in C Safe, and When Does it Lead to Undefined Behavior?. For more information, please follow other related articles on the PHP Chinese website!