C++ interface class causes ambiguous function call (Qt) - c++

Question

This may be due to me not entirely understanding how interfaces in C++ work, but here we go:
I have base interface for a property class in QT5.
class IBaseProperty
{
public:
virtual ~IBaseProperty() {}
// Returns the property key as a string.
virtual QString getKey() = 0;
// Returns the property value as a raw string.
virtual QString getValueRaw() = 0;
// Sets the property key as a string.
virtual void setKey(QString key) = 0;
// Sets the property value as a raw string.
virtual void setValueRaw(QString value) = 0;
};
I also have a templated interface extension to make it easier to subclass properties that handle more specific data types.
template <class T>
class IProperty : public IBaseProperty
{
public:
virtual ~IProperty() {}
// Classifies a property with a Property_t identifier.
virtual Property_t getPropertyType() = 0;
// Returns the property value as the specified type.
// Bool is true if conversion was successful.
virtual T getValue(bool* success) = 0;
// Sets the property value as the specified type.
virtual void setValue(T value) = 0;
// Returns whether the current value can be converted correctly
// to the specified type.
virtual bool canConvert() = 0;
};
My base property (implementing only IBaseProperty) looks like this:
class BaseProperty : public QObject, public IBaseProperty
{
Q_OBJECT
public:
explicit BaseProperty(QObject *parent = 0, QString key = "", QString value = "");
virtual QString getKey();
virtual QString getValueRaw();
public slots:
virtual void setKey(QString key);
virtual void setValueRaw(QString value);
protected:
QPair<QString, QString> m_Property; // KV pair this property holds.
};
I subclass this to make a string property - obviously the base property can just return strings, but I wanted to keep the same function format between string/int/float/etc. properties by allowing getValue in all of them. GetValue in this case simply calls getValueRaw to return the value.
class StringProperty : public BaseProperty, public IProperty<QString>
{
Q_OBJECT
public:
explicit StringProperty(QObject *parent = 0, QString key = "", QString value = "");
virtual inline Property_t getPropertyType() { return Prop_String; }
virtual QString getValue(bool* success);
virtual bool canConvert();
public slots:
virtual void setValue(QString value);
};
The ambiguity occurs when I implement getValue and setValue:
inline QString StringProperty::getValue(bool* success)
{
*success = canConvert();
return getValueRaw(); // This line causes the ambiguity.
}
The compiler complains:
C2385: Ambiguous access of 'getValueRaw': could be the 'getValueRaw'
in base 'BaseProperty' or could be the 'getValueRaw' in base
'IBaseProperty'.
I'm not entirely sure what to do in this situation - I would have thought that IBaseProperty being a pure virtual class would mean that the function would not be able to be called from this point anyway, so would only be called from where it was implemented (BaseProperty). What would be the correct course of action to take to fix this? I'm not sure from which base class I should be calling the function.

Answer 1

For the first look, it seems to be classical diamond problem or diamond inheritance
String property inherits from BaseProperty and IProperty, and both of them have same base class IBaseProperty. That's why there is an ambiguity.

Answer 2

The problem is that a StringProperty contains two base class subobjects of type IBaseProperty. You probably want just one IBaseProperty, in which case you need to use virtual inheritance. (It's often a good idea for "interfaces" to be virtual base classes.)
template <class T>
class IProperty : public virtual IBaseProperty
{ /*...*/ };
class BaseProperty : public virtual IBaseProperty, public QObject
{ Q_OBJECT; /*...*/ };
class StringProperty : public virtual IProperty<QString>, public BaseProperty
{ Q_OBJECT; /*...*/ };
Recommended reading: C++ FAQ 25.8 through 25.15.