c++ 覆盖函数

w46czmvw 于 2023-04-13 发布在其他

关注(0)|答案(1)|浏览(103)

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);
}

所以问题是，如果我从D& EQUAL(const D& M) override中删除关键字“override”，这段代码就可以工作了。但我不明白为什么它不能工作。在Clion中，在“override”一词下出现了红线，并说“标记为'override'的非虚拟成员函数隐藏了虚拟成员函数隐藏了重载的虚拟函数'S：：EQUAL'在这里声明：第一个参数的类型不匹配（'const S &' vs 'const D &'）"。我不明白为什么它会混淆const S&和const D&。有人能解释一下吗？

c++

来源：https://stackoverflow.com/questions/75971921/overriding-a-function

1条答案

按热度按时间

6ljaweal1#

既然这个问题已经相当安静，我想我会尝试回答它，即使OP想要解决的问题仍然相当模糊。
在我看来，问题是如何在类S和D的代码重复最少的情况下实现operator=。因此，在这个假设下，我会这样做：

#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函数。
不涉及多态性;只是老式的函数重载。

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

赞(0）回复(0）举报 2023-04-13

我来回答

c++ 覆盖函数

1条答案

相关问题

热门标签

最新问答