重载技巧

Question

考虑这段代码：

#include <iostream>

class A {
public:
    template <typename... Args> void execute(Args&&... args) {foo(std::forward<Args>(args)...);}
    template <typename... Args> void doIt(Args&&... args) {bar(std::forward<Args>(args)...);}
private:
    void foo() {}
    void foo(int) {}
    void foo(int, char) {}
    void foo(bool, int, double) {}
    void bar() {foo();}  // *** Added
    void bar(int) {}
    void bar(int num, char c) {foo(num, c);}  // *** Added
    void bar(bool, int, double) {}
};

int main() {
    A a;
    a.doIt();
    a.doIt(5,'t');
}

A::doIt 将具有与A::execute 相同的重载类型，并且将对其中一些使用bar 的重载（其中 bar 的重载是唯一的），并为其他使用foo 的重载。为此，我简单地添加了void bar() {foo();} 和void bar(int num, char c) {foo(num, c);}。这不是那么痛苦，但假设有很多这样的转发要做。并在需要 doIt 的新重载时考虑维护问题，并为它们定义新的 foo 重载（容易忘记转发的东西）。

有没有办法删除这些额外的bar 重载（只需转发到foo），而是修改当前定义的doIt(Args&&... args) 函数，以便在不存在此类条形重载的情况下调用@987654333 @的重载而不是？所以换句话说，删除我添加的两个bar 重载，由于doIt 的新定义，main() 仍然可以按预期编译。

Answer 1

SFINAE 关于bar(std::forward<Args>(args)...) 的格式良好。

class A {
private:
    void foo();
    void foo(int);
    void foo(int, char);
    void foo(bool, int, double);
    void bar(int);
    void bar(bool, int, double);

    template <typename... Args> 
    auto doIt_impl(int, Args&&... args) -> decltype(bar(std::forward<Args>(args)...)){
        bar(std::forward<Args>(args)...);
    }
    template <typename... Args> 
    auto doIt_impl(long, Args&&... args) -> void {
        foo(std::forward<Args>(args)...);
    }

public:
    template <typename... Args> void doIt(Args&&... args) {
        doIt_impl(0, std::forward<Args>(args)...);
    }
};

虚拟的第一个参数确保doIt_impl 的bar-calling 重载在可行的情况下是首选的。另外，需要注意的是尾随返回类型不会进行类范围查找，因此doIt_impl 的声明必须在bars 的声明之后。

Demo.

Answer 2

感谢 nwp 的提示（虽然我不确定这是否是他的意思）和 T.C. 的调试提示，我有了这个替代解决方案。但是 T.C. 的解决方案要好得多。

#include <iostream>

class A_Foo {
protected:
    virtual void foo() {std::cout << "foo().\n";}
    virtual void foo(int) {std::cout << "foo(int).\n";}
    virtual void foo(int, char) {std::cout << "foo(int, char).\n";}
    virtual void foo(bool, int, double) {std::cout << "foo(bool, int, double).\n";}
};

class A_Bar : private A_Foo {
public:
    using A_Foo::foo;  // This is needed.  Else all the declarations of foo in A_Foo are hidden.
    virtual void foo(int) override {std::cout << "bar(int).\n";}
    virtual void foo(bool, int, double) override {std::cout << "bar(bool, int, double).\n";}
};

class A : private A_Bar {
public:
    template <typename... Args> void execute(Args&&... args) {
        A_Foo::foo(std::forward<Args>(args)...);
    }
    template <typename... Args> void doIt(Args&&... args) {
        A_Bar::foo(std::forward<Args>(args)...);
    }
};

int main() {
    A a;
    a.doIt();  // foo().
    a.doIt(5);  // bar(int).
    a.doIt(5,'t');  // foo(int, char).
    a.doIt(true,5,1.8);  // bar(bool, int, double).
}