基类指针指向派生类实例时，如何访问派生类私有成员？

Absolutely, there are two common and safe ways to achieve this in C++, depending on your design requirements. Let's break them down with code examples tailored to your class structure.

Method 1: Use dynamic_cast for Safe Downcasting #

This approach lets you convert the base class pointer to a derived class pointer safely, but it requires your base class to be polymorphic (meaning it has at least one virtual function, like a virtual destructor).

First, update your base class to include a virtual destructor (this is also good practice to avoid memory leaks when deleting derived objects via base pointers):

class Airplane { 
private: int value; 
public: 
    // Add virtual destructor to make Airplane polymorphic
    virtual ~Airplane() = default;
    
    // Public function to modify base class's private member
    void setValue(int v) { value = v; }
    int getValue() const { return value; }
};

Your derived class stays mostly the same, with public functions to modify its private member:

class Model : public Airplane { 
private: bool flag; 
public: 
    // Public function to modify derived class's private member
    void setFlag(bool f) { flag = f; }
    bool getFlag() const { return flag; }
};

Now, use dynamic_cast to safely access the derived class's functions:

Airplane* A = new Model();

// Call base class function to modify `value` directly
A->setValue(100);

// Safely cast base pointer to derived pointer
if (Model* modelPtr = dynamic_cast<Model*>(A)) {
    // Now you can call Model's public functions to modify `flag`
    modelPtr->setFlag(true);
    
    // You can also call base class functions through the derived pointer if needed
    modelPtr->setValue(200);
}

Key Notes: #

• dynamic_cast performs a runtime check: if the base pointer actually points to a Model object, it returns a valid Model*; otherwise, it returns nullptr. The if check ensures you don't access a null pointer.
• Without a virtual function in the base class, dynamic_cast will fail to compile.

Method 2: Use Polymorphism with Virtual Functions #

If modifying the derived class's flag is a common operation that should be accessible via the base class interface, define virtual functions in the base class that the derived class overrides. This follows OOP principles and avoids explicit casting.

Update the base class to include virtual functions for the derived class's operations:

class Airplane { 
private: int value; 
public: 
    virtual ~Airplane() = default;
    
    void setValue(int v) { value = v; }
    int getValue() const { return value; }
    
    // Define virtual functions for derived class-specific operations
    virtual void setFlag(bool f) = 0; // Pure virtual function (makes Airplane abstract)
    virtual bool getFlag() const = 0;
};

Override these virtual functions in the derived class:

class Model : public Airplane { 
private: bool flag; 
public: 
    // Override base class virtual functions to modify `flag`
    void setFlag(bool f) override { flag = f; }
    bool getFlag() const override { return flag; }
};

Now you can call both base and derived operations directly via the base class pointer:

Airplane* A = new Model();

// Modify base class's `value`
A->setValue(50);

// Modify derived class's `flag` directly through the base pointer
A->setFlag(false);

Key Notes: #

• Using pure virtual functions (= 0) makes the base class Airplane abstract, meaning you can't instantiate Airplane objects directly—only derived classes like Model.
• If you need to instantiate the base class, you can provide a default implementation for the virtual functions instead of making them pure (e.g., virtual void setFlag(bool f) {}), but ensure this default behavior makes sense for your use case.

Which to Choose? #

• Use dynamic_cast if you only occasionally need to access derived-specific members, or if you have multiple derived classes and need to handle them conditionally.
• Use virtual functions if the derived-specific operation is part of a common interface that all derived classes should implement, as this keeps your code more maintainable and aligned with OOP design.

内容的提问来源于stack exchange，提问作者Max