Question

我找不到函数隐藏和重载之间的任何区别。因为函数隐藏是派生类中存在的函数，并且隐藏基类的函数。它们在两个函数中具有相同的名称。重载：在派生类和基类中具有相同的名称，但签名不同。

$('body').on({
    'touchmove': function(e) {
     console.log($(this).scrollTop());
    }
});

它是隐藏功能还是重载？

Answer 1

函数B::print 隐藏父函数A::print。

如果要重载，则需要将A::print函数拉入B的范围内：

class B : public A {
public:
    using A::print;  // Pull in (all) A::print symbols into the scope of B

    void print(float);  // Now overloads A::print
};

Answer 2

在范围内定义的名称隐藏在任何外部范围内具有相同名称的声明。像这样：

int name; // global name

void f() {
    int name; // name 1, hides global name
    for (int i = 0; i < 10; i++) }
        int name; // name 2, hides name 1 and global name
        name = 3; // assigns 3 to name 2
    }
    name = 4; // assigns 4 to name 1
}

int other = name; // copies value of global name into other

当在相同范围内声明具有相同名称的两个或多个函数时，该名称将被重载：

// two functions in global scope:
void f();
void f(int);

void g() {
    f();  // ok: calls first version of f
    f(1); // ok: calls second version of f
}

不同作用域中的定义不要定义重载集，因为内部作用域中的声明在任何外部作用域中都隐藏相同的名称。

class cl1 {
public:
    // hides global f's:
    void f();

    void g() {
        f();  // ok: calls cl1::f()
        f(1); // error: no f takes an int; global f(int) is hidden
    }
};

当然，即使在外部作用域中有多个具有相同（隐藏）名称的功能，在同一作用域中定义多个函数仍然会定义重载。

class cl2 {
public:
    // these hide global f's, and provided overloads:
    void f();
    void f(int);

    void g() {
        f();  // calls cl2::f()
        f(1); // calls cl2::f(int)
    }
};

类定义提供了新的作用域，因此有关名称隐藏和重载的规则适用于该类中定义的名称。

class cl3 : public cl2 {
        void g() {
            f();  // calls cl2::f()
            f(1); // calls cl2::f(int)
        }
    };

class cl4 : public cl2 {
    // hides all f's:
    void f();

    void g() {
        f();  // ok: calls cl4::f();
        f(3); // error: no f takes an int; global f(int) and cl2::f(int) are hidden
    }
};

class cl5 : public cl2 {
    // hides all f's and provides overloads:
    void f();
    void f(int);

    void g() {
        f();  // ok: calls cl5::f()
        f(3); // ok: calls cl5::f(int)
    }
};

您还可以使用与基类中的任何签名都不匹配的签名。毕竟，那些基类函数的名称是隐藏的。

class cl5 : public cl2 {
public:
    // hides all f's:
    void f(std::string);

    void g() {
        f();       // error: no f taking no arguments
        f(3);      // error: no f taking int
        std::string arg("test");
        f(arg); // ok: calls cl5::f(std::string)
    }
};

最后，如果要编写一个派生类，以向基类中定义的一组重载函数添加签名，则必须将这些重载函数的名称添加至派生类：

class cl6 : public cl2 {
public:
    using cl2::f;        // pull cl2::f into current scope
    void f(std::string); // add overload to names from cl2

    void g() {
        f();    // ok: calls cl2::f()
        f(3);   // ok: calls cl2::f(int)
        std::string arg("test");
        f(arg); // ok: calls cl6::f(std::string)
    }
};

函数隐藏和重载之间的区别

2 个答案: