Question about polymorphism and mulitipule inheritance - c++

Question

I hope to store the data in three different ways:
1.store to a std::string
2.write to file descriptor
3.both of the above
And I hope to use a uniform interface for these three different methods.
I wrote a simple code sippet to achieve the said goals. The first & second are easy indeed, but for the third I am stuck.
Please pay attention to the comment in the code snippet below, which is what the compiler complains if STORE_BY_FD_AND_STRING is defined.
Here is the code snippet:
#include <memory>
#include <iostream>
#include <unistd.h>
class DataStorage {
public:
DataStorage(int total_count):total_count_(total_count){};
virtual int Store(const char *buffer, int count) = 0;
virtual ~DataStorage(){};
protected:
int total_count_;
};
class DataStorageByStr : public DataStorage {
public:
DataStorageByStr(std::string &str) : str_(str), DataStorage(0){};
int Store(const char *buffer, int count)
{
str_ += std::string(buffer, count);
total_count_ += count;
return 0;
};
protected:
std::string &str_;
};
class DataStorageByFd : public DataStorage {
public:
DataStorageByFd(int &fd):fd_(fd), DataStorage(0){};
int Store(const char *buffer, int count)
{
int ret = write(fd_, buffer, count);
if(ret > 0)
{
total_count_ += ret;
}
return ret;
};
protected:
int &fd_;
};
class DataStorageByStrAndFd : public DataStorageByStr, public DataStorageByFd {
public:
DataStorageByStrAndFd(std::string &str, int &fd):DataStorageByStr(str), DataStorageByFd(fd) {}
int Store(const char *buffer, int count)
{
int ret1 = DataStorageByStr::Store(buffer, count);
int ret2 = DataStorageByFd::Store(buffer, count);
return ((0==ret1) && (0==ret2))?0:-1;
}
};
int StoreSomeData(DataStorage *pstorage, const std::string data_to_store)
{
return pstorage->Store(data_to_store.data(), data_to_store.length());
}
int main()
{
{
std::string str{"storing the string to std::string works !"};
std::string data;
DataStorage *pstorage = new DataStorageByStr(data);
StoreSomeData(pstorage, str);
std::cout << data << std::endl;
}
{
std::string str{"storing the string to fd works !"};
int fd = 1;
DataStorage *pstorage = new DataStorageByFd(fd);
StoreSomeData(pstorage, str);
}
#ifdef STORE_BY_FD_AND_STRING
{
std::string str{"thanks for your attention for this matter!"};
std::string data;
int fd = 1;
DataStorage *pstorage = new DataStorageByStrAndFd(str, fd); //The compiler complain that 'DataStorage' is an ambiguous base of 'DataStorageByStrAndFd'
StoreSomeData(pstorage, str);
}
#endif
}
Any sugestion to achieve all the aforementioned goals?

Answer 1

Thanks to #Sam Varshavchik #Adrian Mole. This code snippet works.
#include <memory>
#include <iostream>
#include <unistd.h>
class DataStorage {
public:
DataStorage(int total_count):total_count_(total_count){};
virtual int Store(const char *buffer, int count) = 0;
virtual ~DataStorage(){};
protected:
int total_count_;
};
class DataStorageByStr : virtual public DataStorage {
public:
DataStorageByStr(std::string &str) : str_(str), DataStorage(0){};
int Store(const char *buffer, int count)
{
str_ += std::string(buffer, count);
total_count_ += count;
return 0;
};
protected:
std::string &str_;
};
class DataStorageByFd :virtual public DataStorage {
public:
DataStorageByFd(int &fd):fd_(fd), DataStorage(0){};
int Store(const char *buffer, int count)
{
int ret = write(fd_, buffer, count);
if(ret > 0)
{
total_count_ += ret;
}
return ret;
};
protected:
int &fd_;
};
class DataStorageByStrAndFd : public DataStorageByStr, public DataStorageByFd {
public:
DataStorageByStrAndFd(std::string &str, int &fd):DataStorageByStr(str), DataStorageByFd(fd), DataStorage(0)
{
}
int Store(const char *buffer, int count)
{
int ret1 = DataStorageByStr::Store(buffer, count);
int ret2 = DataStorageByFd::Store(buffer, count);
return ((0==ret1) && (0==ret2))?0:-1;
}
};
int StoreSomeData(DataStorage *pstorage, const std::string data_to_store)
{
return pstorage->Store(data_to_store.data(), data_to_store.length());
}
int main()
{
{
std::string str{"storing the string to std::string works !"};
std::string data;
DataStorage *pstorage = new DataStorageByStr(data);
StoreSomeData(pstorage, str);
std::cout << data << std::endl;
}
{
std::string str{"storing the string to fd works !"};
int fd = 1;
DataStorage *pstorage = new DataStorageByFd(fd);
StoreSomeData(pstorage, str);
}
#ifndef STORE_BY_FD_AND_STRING
{
std::string str{"thanks for your attention for this matter!"};
std::string data;
int fd = 1;
DataStorage *pstorage = new DataStorageByStrAndFd(str, fd); //The compiler complain that 'DataStorage' is an ambiguous base of 'DataStorageByStrAndFd'
StoreSomeData(pstorage, str);
}
#endif
}
Explanation:
Virtual inheritance is a C++ technique that ensures only one copy of a base class's member variables are inherited by grandchild derived classes. Without virtual inheritance, if two classes B and C inherit from a class A, and a class D inherits from both B and C, then D will contain two copies of A's member variables: one via B, and one via C. These will be accessible independently, using scope resolution.
Instead, if classes B and C inherit virtually from class A, then objects of class D will contain only one set of the member variables from class A.
This feature is most useful for multiple inheritance, as it makes the virtual base a common subobject for the deriving class and all classes that are derived from it. This can be used to avoid the diamond problem by clarifying ambiguity over which ancestor class to use, as from the perspective of the deriving class (D in the example above) the virtual base (A) acts as though it were the direct base class of D, not a class derived indirectly through a base (B or C).