How to declare a class member that may be one of two classes-CodePudding

I am working with a project that is largely not of my creation, but am tasked with adding in some functionality to it. Currently, there is a device class that has a member variable that is responsible for storing information about a storage location, setup like this:

device.hpp

class device {
    public:
        // Stuff
    private:
        // Stuff
        StorageInfo storage_info_;
        // Even more stuff
}

StorageInfo.hpp

class StorageInfo {
    public:
        void initializeStorage();
        void updateStorageInfo();
        int popLocation();
        int peakLocation();
        uint16_t totalSize();
        uint16_t remainingSize();
        // More declarations here
    private:
        //Even more stuff here
}

I am tasked with implementing a different storage option so that the two can be switched between. The information functions that this new storage option has would be the same as the initial storage option, but the implementation in retrieving that information is vastly different. In order to keep things clean and make it easier to maintain this application for years to come, they really need to be defined in two different files. However, this creates an issue inside of device.cpp, and in every single other file that calls the StorageInfo class. If I create two separate member variables, one for each type of storage, then not only will I need to insert a million different ifelse statements, but I have the potential to run into initialization issues in the constructors. What I would instead like to do is have one member variable that has the potential to hold either storage option class. Something like this:

StorageInfoA.hpp

class StorageInfoA: StorageInfo {
    public:
        void initializeStorage();
        void updateStorageInfo();
        int popLocation();
        int peakLocation();
        uint16_t totalSize();
        uint16_t remainingSize();
        // More declarations here
    private:
        //Even more stuff here
}

StorageInfoB.hpp

class StorageInfoB: StorageInfo {
    public:
        void initializeStorage();
        void updateStorageInfo();
        int popLocation();
        int peakLocation();
        uint16_t totalSize();
        uint16_t remainingSize();
        // More declarations here
    private:
        //Even more stuff here
}

device.hpp

class device {
    public:
        // Stuff
    private:
        // Stuff
        StorageInfo storage_info_;
        // Even more stuff
}

device.cpp

//Somewhere in the constructor of device.cpp
if(save_to_cache){
    storage_info_ = StorageInfoA();
} else {
    storage_info_ = StorageInfoB();
}

// Then, these types of calls would return the correct implementation without further ifelse calls
storage_info_.updateStorageInfo();

However, I know that cpp absolutely hates anything with dynamic typing, so I don't really know how to implement this. Is this kind of thing even possible? If not, does anyone know of a similar way to implement this that does work with cpp's typing rules?

CodePudding user response：

You are on the right track, but you have to learn how to use polymorphism. In your example, you need the following fixes:

In the base class, make all functions virtual, and add a virtual destructor:

class StorageInfo {
    public:
        virtual ~StorageInfo(){}
        virtual void initializeStorage();
        //...
 };

Make your inheritance public:

class StorageInfoA: public StorageInfo {

Instead of holding StorageInfo by value, hold it in a smart pointer:

class device {
    private:
        std::unique_ptr<StorageInfo> storage_info_;        
};

device constructor will look like

//Somewhere in the constructor of device.cpp
if(save_to_cache){
    storage_info_ = std::make_unique<StorageInfoA>();
} else {
    storage_info_ = std::make_unique<StorageInfoB>();
}

Finally, you will use it like an ordinary pointer:

    storage_info_->updateStorageInfo();