覆盖函数

Question

template<typename T>
class ITF{
public:
virtual  T& EQUAL(const T& K) = 0;
};
class S : public virtual ITF<S> {
private:
char *Name;
int k;
float IQ;
public:
S &operator=(const S &K);
S &EQUAL(const S &K) override;
};
S& S::EQUAL(const S &K){
if(this != &K)
{
if(this -> Name != nullptr)
{
delete[] Name;
(*this).Name = nullptr;
}
this -> Name = new char[strlen(K.Name) + 1];
strcpy(Name, K.Name);
k = K.k;
IQ = K.IQ;
}
return *this;
}
S& S::operator = (const S& K){
return (*this).EQUAL(K);
}

class D : public virtual  S{
private:
bool Ra;
public:
D &operator=(const D &M);
D& EQUAL(const D& M) override{
S::EQUAL(M);
Ra = M.Ra;
return *this;
}
};
D& D::operator = (const D& M){
return (*this).EQUAL(M);
}

问题是，如果我要删除关键字"override"源自D& EQUAL(const D& M) override。但我不明白为什么它不适合它。在lion中，在"覆盖"一词下出现了那条红线，然后说标记为'override'的非虚成员函数隐藏虚成员函数隐藏重载虚函数'S::EQUAL'在这里声明:第一个形参类型不匹配('const S &' vs 'const D &')"我不明白为什么它会让人困惑。带着一个常量D&有人能解释一下吗?

Answer 1

既然这个问题已经变得相当安静，我想我应该试着回答它，即使OP想要解决的问题仍然相当模糊。

在我看来，问题是如何实现operator=与最小的代码重复类S和D。因此，在这个假设下，我会这样做:

#include <iostream>
#include <cstring>
template<typename T>
class ITF
{
};
class S : public virtual ITF <S>
{
private:
char *Name = nullptr;
int k = 0;
float IQ = 0;
public:
S &operator= (const S &K);
};
S& S::operator = (const S &K)
{
if (this != &K)
{
delete [] Name;
Name = nullptr;
if (K.Name)
{
Name = new char [strlen (K.Name) + 1];
strcpy (Name, K.Name);
}

k = K.k;
IQ = K.IQ;
}
return *this;
}
class D : public virtual  S
{
private:
bool Ra;
public:
D &operator= (const D &M);
D& operator= (const S &M);
};
D& D::operator= (const D &M)
{
if (this != &M)
{
S::operator= (M);
Ra = M.Ra;
}
return *this;
}
D& D::operator= (const S &M)
{
S::operator= (M);
return *this;
}
int main ()
{
S s1;
S s2;
D d1;
D d2;
d1 = d2;
s1 = s2;
d1 = s2;
}

指出:

• 当复制D时，可以显式地调用S::operator=(我认为这是OP缺少的关键部分)。
• 导致我们误入歧途的EQUAL函数因此不再需要。
• 不涉及多态性;

说了这么多，这可能不能很好地扩展(但是您可能会质疑类层次结构的设计)。

现场演示