Parametrieren Vorlage von Funktionsnamen C++ 11

Question

mit folgenden Funktionen

void print(int a) { cout << a << endl; } 
void print(std::string a) { cout << a << endl; } 

Sie können

template <class T> void printT(T a) { print(a); } 

Gibt es die folgende Vorlage tun einige Mechanismus, um die Funktionsnamen parametrisieren? Etwas wie folgt aus:

template <class T, class F> void anyT(T a) { F(a); } 

Ich brauche nicht eine Funktionsvorlage sein, nur einen Mechanismus, das gleiche zu erreichen.

Answer 1

Ja, können Sie den Anrufer als Funktionszeiger übergeben, die T wie unten als Eingabe:

template <class T> void anyT(T a, void(*f)(T)) { 
    f(a); 
} 

Live Demo

Answer 2

kämpfen, um die Gründe hier zu verstehen. In C++ 14 haben wir Lambdas mit automatischen Argumenten. Wird das das lösen?

#include <iostream> 

int main() { 


    int a = 1; 
    std::string str = "string"; 

    auto print = [] (const auto& a) { std::cout << a << std::endl; }; 

    print(a); 
    print(str); 
} 

Answer 3

Sie können die Funktion als Parameter übergeben.

template <class T, class F> 
void anyT(T a, F f) { 
    f(a); 
} 

Dies hat der Vorteil im Vergleich zu einem Funktionszeiger mit Templat-Argumente Typ von 101010 vorgeschlagen vorbei ist, dass dies auch als functors (Instanzen von jeder Art mit Funktionszeiger arbeitet, die operator() wie Lambda-Ausdrücke implementieren.

der Nachteil besteht darin, dass ein Funktionszeiger einer überladene Funktion immer im Zusammenhang mit dem frei Templat Parameter kann schwierig sein. Sie bräuchten

void (*f)(int) = print; 
anyT(a, f); 

Oder alternativ, wickeln Sie es in einem Lamm verwenden wie von GuyGreer vorgeschlagen.

Answer 4

Ich persönlich würde mit 101010 Lösung gehen, aber Sie scheinen nicht den Funktionszeiger als Funktionsparameter, sondern nur als Vorlageparameter übergeben möchten. Hier ist, wie können Sie das tun:

#include <string> 

    template <class T, void(*func)(T)> 
    void anyT(T t) 
    { 
     func(t); 
    } 

    void print(int i){} 
    void print(std::string s){} 

    int main() 
    { 
     anyT<int, print>(1); 
     anyT<std::string, print>("hello"); 
    } 

Leider ist es bedeutet, dass Sie die Template-Parameter für die Funktion jedes Mal angegeben werden, die eine Drag ist.

Die bessere Lösung Ich denke, wäre, nur einen generischen Template-Parameter zu verwenden und eine Lambda:

template <class T, class F> 
    void anyT(T t, F f) 
    { 
     f(t); 
    } 

    auto printT = [](auto i){print(i);} 
    anyT(0, printT); 

Das Lambda ist notwendig, da vorbei print direkt mehrdeutig sein würde, wird der Compiler nicht wissen, ob Sie bedeuten print(int) oder print(std::string).

Answer 5

Dies ist ein nützliches Makro:

#define OVERRIDES_OF(...) [](auto&&...args)->decltype(auto){ return __VA_ARGS__ (decltype(args)(args)...);} 

das Ergebnis ist ein stateless Lambda, die zur Verfügung gestellt, um die Token weiterleitet.

Verwendung:

static const auto printT = OVERRIDES_OF(print); 

jetzt printT ist ein Objekt, das alle der Überschreibungen von print hüllt.

Answer 6

Sie können die Funktion über einen Funktionszeiger übergeben:

template <class T> void anyT(T a, void(*F)(T)) { F(a); } 

aber dann kann man nicht einen Lambda-Pass:

auto printStr = [](std::string a) { cout << a << endl; }; 
anyT(foo, printStr); // This won't compile 

Ein alternativer Ansatz wäre std::function zu verwenden:

template <class T> 
void anyT(T a, std::function<void(T)> F) { F(a); } 

oder ein generischer Vorlagenparameter:

template <class T, class F> 
void anyT(T a, F func) { func(t); } 

Dies hat den Nachteil, dass es nicht überladene Funktionen lösen können, aber Sie können eine Hilfsfunktion verwenden:

template<typename F> 
std::function<F> make_function(F *funPtr) { 
    return std::function<F>(static_cast<F*>(funPtr)); 
} 

und anyT wie folgt aufrufen:

string foo = "foo"; 
anyT(foo, make_function<void(std::string)>(&print));