C++中DataStructure类继承ConstDataStructure类的实现问询

Great question! Let's walk through how to properly make DataStructure inherit from ConstDataStructure while maintaining const-correctness and avoiding redundant code. The main hurdles here are resolving naming conflicts between the member variables/methods and ensuring the inheritance doesn't break the intended behavior of either class.

Key Design Adjustments & Implementation #

The core idea is to let ConstDataStructure serve as a read-only base class, while DataStructure extends it with write capabilities. Here's the step-by-step implementation:

1. Refactor the ConstDataStructure Base Class

First, we need to adjust the base class to support inheritance properly:

• Change the data_ member's access from private to protected so the subclass can access it.
• Update data_'s type to unsigned char* (since the subclass needs to modify it; the base class will still enforce read-only access via its data() method).
• Ensure the destructor remains virtual to guarantee proper cleanup for subclass objects.

class ConstDataStructure {
public:
    ConstDataStructure() : data_(nullptr) {}
    virtual ~ConstDataStructure() {
        delete[] data_; // Clean up allocated memory
    }

    // Read-only access for all users
    const unsigned char* data() const {
        return data_;
    }

protected:
    unsigned char* data_; // Accessible to subclasses, hidden from external code
};

2. Implement the DataStructure Subclass

Now have DataStructure publicly inherit from ConstDataStructure, and add the write-specific functionality:

• Remove the redundant data_ member in DataStructure (we'll reuse the base class's data_).
• Implement a non-const version of data() to provide write access.
• Keep the setData template method, modified to operate on the base class's data_.

class DataStructure : public ConstDataStructure {
public:
    DataStructure() : ConstDataStructure() {} // Delegate to base class constructor

    // Write-access version of data() (overloads the base class's const version)
    unsigned char* data() {
        return data_;
    }

    template <class T>
    void setData(T data) {
        // Example implementation: Clean up existing memory first
        delete[] data_;
        // Allocate new memory and copy the input data
        data_ = new unsigned char[sizeof(T)];
        *reinterpret_cast<T*>(data_) = data;
    }
};

Critical Notes to Understand #

• Const-Correctness: The base class's const unsigned char* data() const ensures read-only access for code that only has a ConstDataStructure reference/pointer. The subclass's non-const unsigned char* data() provides write access when working with DataStructure instances—this is valid overloading in C++ since the const qualifier is part of the member function's signature.
• Memory Management: The base class's virtual destructor ensures that when a DataStructure object is destroyed, the data_ memory is properly freed. The setData method includes basic cleanup logic, but you may want to expand this (e.g., handle null inputs, support array types, or use smart pointers for safer memory management).
• Avoiding Redundancy: By reusing the base class's data_ instead of defining a separate member in DataStructure, we eliminate duplicate state and simplify maintenance.

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