Wie benutze ich "using" für eine Funktion?

Question

Wie benutzt man "using" für eine Funktion? Zum Beispiel

class A; 
void f(int); 

struct B 
{ 
    using BA = A; 
    using Bf = f; ??? 
}; 

Answer 1

Sie können

struct B 
{ 
    using BA = A; 
    constexpr static auto Bf = f; 
} 

diese Weise können Sie die Art zu spezifizieren keine Sorge zu tun haben, was ärgerlich sein kann.

Sie möchten keine nicht statische Variable deklarieren, andernfalls wird jede einzelne Kopie Ihres Objekts einen Funktionszeiger enthalten. Sie möchten auch nicht, dass es veränderbar ist, denn dann können Sie es neu zuweisen. Sie wollen auch nicht, dass es zur Laufzeit potentiell bestimmt wird, denn dann muss sich der Compiler in einem gegebenen Kontext beweisen, dass ein Aufruf an Bf wirklich f aufruft, oder aber Funktions-Indirektionskosten bezahlen. Die constexpr behandelt diese letzten zwei Punkte.

Answer 2

Wenn f ist nur eine Funktion, können Sie entweder ein Mitglied Funktionszeiger hinzufügen:

void (*Bf)(int) = f; 

oder es nur in einer Funktion wickeln:

void Bf(int i) { f(i); } 

bevorzugen wohl Letzteres, wie es vermeidet, zusätzliche Mitglieder zu B hinzuzufügen.

---

Wenn f eine Funktionsschablone ist, können Sie nicht nur alias, würden Sie brauchen, um es zu übermitteln:

template <class... Args> 
auto Bf(Args&&... args) 
    -> decltype(::f(std::forward<Args>(args)...)) 
    noexcept(noexcept(::f(std::forward<Args>(args...)))) 
{ 
    return ::f(std::forward<Args>(args)...); 
} 

das ist ... ja.

Answer 3

Nir Friedman's answer ist großartig, aber es wird nicht funktionieren, falls f überlastet ist.

In C++ 14 können Sie eine Lösung für diese mit a generic lambda haben:

struct B { 
    using BA = A; 
    static constexpr auto BF = [](auto&&... args) { 
    return f(std::forward<decltype(args)>(args)...); 
    }; 
}; 

Wenn das ein complicat Bit scheint, die nur wegen std::forward ‚s Ausführlichkeit ist. Ich werde es zeigen, ohne std::forward, um es einfacher zu machen zu erreichen (dies aber nicht verwenden, da es würde scheitern, wenn f Referenztypen als params hat):

struct B { 
    using BA = A; 
    static constexpr auto BF = [](auto... args) { return f(args...); }; 
}; 

Answer 4

Der Unterschied besteht darin, dass A ist nur eine Art, während f ist eine tatsächliche Funktion. Wenn Sie using verwenden definieren Bf als Typ von f wollen, dann verwenden:

using Bf = decltype(f);