3

例如，在下面的程序中，我通过“使用”关键字撤消名称隐藏。如果我有基类和一个派生类“我得到预期的模棱两可的调用错误”。但是，如果我现在有两个派生类（孩子和孙子），孩子和孙子在这里具有相同的重载函数，我也会通过“使用”关键字撤消名称隐藏。但它正在被编译并得到输出。我的问题是为什么我没有收到“对重载函数的模糊调用”的错误。

class baseNameHiding
{
protected:
int nameHidingexample(int t)
{
    cout<<"im baseeeeeeeeeeee"<<endl;
    return 0;
}
};
class derivedNameHiding:public baseNameHiding
{   
public:
    float nameHidingexample(float s)
    {
        cout<<"im derived"<<endl;
        return 0;
    }
    using baseNameHiding::nameHidingexample;

};
class grandDerivedNameHiding:public derivedNameHiding
{
public:
    float nameHidingexample(float f)
    {
        cout<<"im grand derived"<<endl;
        return 0;
    }
    using baseNameHiding::nameHidingexample;
    using derivedNameHiding::nameHidingexample;

};
int main()
{
    char a;float f = 0.0;
    derivedNameHiding derived;
    derived.nameHidingexample(0);
    grandDerivedNameHiding grandchild;
    grandchild.nameHidingexample(f);
    cin>>a;
} 


//output
im baseeeeeeeeeeee
im grand derived
4

1 回答 1

3

您遇到了使用声明的特殊规则。C++14 [命名空间.udecl]/15：

当using-declaration将基类中的名称带入派生类范围时，派生类中的成员函数和成员函数模板会覆盖和/或隐藏具有相同名称的成员函数和成员函数模板，parameter-type-list， cv -qualification和ref-qualifier（如果有）在基类中（而不是冲突）。[...] [示例：

struct B {
    virtual void f(int);
    virtual void f(char);
    void g(int);
    void h(int);
};

struct D : B {
    using B::f;
    void f(int);    // OK: D::f(int) overrides B::f(int);

    using B::g;
    void g(char);   // OK

    using B::h;
    void h(int);    // OK: D::h(int) hides B::h(int)
};

void k(D* p)
{
    p->f(1);        // calls D::f(int)
    p->f(’a’);      // calls B::f(char)
    p->g(1);        // calls B::g(int)
    p->g(’a’);      // calls D::g(char)
}

—结束示例]

于 2015-03-28T14:29:22.817 回答