是否有可能在C++中有一個函數（-name）作爲模板參數？

Question

我不想函數指針的開銷，我只是想爲兩個不同的功能具有相同簽名相同的代碼：

void f(int x); 
void g(int x); 

... 

template<typename F> 
void do_work() 
{ 
    int v = calculate(); 
    F(v); 
} 

... 

do_work<f>(); 
do_work<g>(); 

這可能嗎？

---

要清除了可能出現的混淆：用「模板參數」我的意思是參數/參數模板和不函數參數類型爲模板。

Answer 1

一種方法是極有可能產生直接的函數調用，因爲它可以讓編譯器沒有選擇，是使用靜態成員函數：

struct F { static void func(int x) { /*whatever*/ } }; 
struct G { static void func(int x) { /*whatever*/ } }; 

template<class T> 
void do_work() { 
    T::func(calculate()); 
} 

沒有函數指針，沒有臨時工，沒有不必要的this。當然，我保證什麼都沒有，但是即使禁用了優化，生成的代碼也應該是合理的。

Answer 2

您可以將指針指向函數作爲模板參數，但函數對象更多的是「C++ ish」。但是，您可以接受這兩個變種的方式寫你的函數模板：

#include <iostream> 

void f(int x) 
{ 
    std::cout << "inside function f\n"; 
} 

struct g 
{ 
    void operator()(int x) 
    { 
     std::cout << "inside function object g\n"; 
    } 
}; 

template <typename Functor> 
void do_work(Functor fun) 
{ 
    fun(42); 
} 

int main() 
{ 
    // template argument is automatically deduced 
    do_work(&f); 
    // but we could also specify it explicitly 
    do_work<void(*)(int)>(&f); 

    // template argument is automatically deduced 
    do_work(g()); 
    // but we could also specify it explicitly 
    do_work<g>(g()); 
} 

這裏，在名稱的任何類型的通過f(x)語法調用Functor提示。函數自然支持這個語法，而在函數對象的情況下，f(x)是語法糖f.operator()(x)。

Answer 3

不，您需要用operator()將函數包裝到包裝類中。以下是一個示例：

class Functor_f 
{ 
public: 
    void operator()(int x) 
    { 
    } 
}; 

class Functor_g 
{ 
    public: 
    void operator()(int x) 
    { 
    } 
}; 



template<typename F> 
void do_work() 
{ 
    F f; 
int v = calculate(); 
    f(v); 
} 


int main() 
{ 
    do_work<Functor_f>(); 
    do_work<Functor_g>(); 

} 

您可以使用std::ptr_fun自動爲您打包。例如：

void f(int x) 
{ 
} 

void g(int x) 
{ 
} 

template<typename F> 
void do_work(F f) 
{ 
int v = calculate(); 
    f(v); 
} 


int main() 
{ 
    do_work(std::ptr_fun(f)); 
    do_work(std::ptr_fun(g)); 

} 

Answer 4

你的點子也沒什麼，但你不能傳遞一個類型，但一個值（具體來講，函數指針>另外，通過一個模板策略提供功能 - 這是一個好主意，閱讀現代。 C++設計由安德烈Alexandrescu的。

#include <iostream> 

int f(int x) { return 2 * x; } 
int g(int x) { return -3 * x; } 

typedef int (*F)(int); 

template<F f> 
int do_work() 
{ 
    return f(7); 
} 

int main() 
{ 
    std::cout << do_work<f>() << '\n' 
       << do_work<g>() << '\n'; 
} 

OR

int calculate() { return 4; } 

struct F { int do_something_with(int x) { return 2 * x; } }; 
struct G { int do_something_with(int x) { return -3 * x; } }; 
// or, make these functions static and use Operator::do_something_with() below... 

template<typename Operation> 
int do_work() 
{ 
    int v = calculate(7); 
    return Operation().do_something_with(v); 
} 

int main() 
{ 
    std::cout << do_work<F>() << '\n' 
       << do_work<G>() << '\n'; 
}