Question

我发现'using'关键字可以在类定义中使用。根据{{3}}，其用于成员函数的方法如下：

如果名称是基的重载成员函数的名称类，将介绍所有具有该名称的基类成员函数。如果派生类已经有一个同名成员，参数列表和资格，派生类成员隐藏或覆盖（不与之冲突）从其引入的成员基类。

示例代码如下：

#include <iostream>
struct B {
    virtual void f(int) { std::cout << "B::f\n"; }
    void g(char)        { std::cout << "B::g\n"; }
    void h(int)         { std::cout << "B::h\n"; }
 protected:
    int m; // B::m is protected
    typedef int value_type;
};

struct D : B {
    using B::m; // D::m is public
    using B::value_type; // D::value_type is public

    using B::f;
    void f(int) { std::cout << "D::f\n"; } // D::f(int) overrides     B::f(int)
    using B::g;
    void g(int) { std::cout << "D::g\n"; } // both g(int) and g(char) are visible
                                       // as members of D
    using B::h;
    void h(int) { std::cout << "D::h\n"; } // D::h(int) hides B::h(int)
};

int main()
{
    D d;
    B& b = d;

//    b.m = 2; // error, B::m is protected
    d.m = 1; // protected B::m is accessible as public D::m
    b.f(1); // calls derived f()
    d.f(1); // calls derived f()
    d.g(1); // calls derived g(int)
    d.g('a'); // calls base g(char)
    b.h(1); // calls base h()
    d.h(1); // calls derived h()
}

从上面的代码中，我不确定有什么区别，例如

using B::f;
void f(int)

和

virtual void f(int)

使用“ using”关键字来覆盖类成员函数是否存在确定的区别？

Answer 1

那篇文章的措词很不幸。他们试图用括号将其修复，但是……

这与虚拟功能覆盖无关。

您给出的两个示例是不同且无关的。

一个将基类f引入范围，然后将其剔除并引入新的D::f函数。（除非按照常规规则，virtual不会是B::f。

另一个声明virtual D::f。

在类定义中使用声明

1 个答案: