テンプレート引数へのポインタを関数の引数として渡しますか？

Question

は、私は与えられた型として扱う2つの入力に対する算術演算を実行するためのC++の関数をしたいと言う：

擬似：OPに合わせ

function(var X,var Y,function OP) 
{ 
if(something) 
    return OP<int>(X,Y); 
else if(something else) 
    return OP<double>(X,Y); 
else 
    return OP<string>(X,Y); 
} 

の機能があるかもしれないように：

template <class T> add(var X,var Y) 
{ 
return (T)X + (T)Y; //X, Y are of a type with overloaded operators 
} 

ですから、関数のシグネチャはどのように見えますか？演算子関数がテンプレート化されていない場合、私はそれを行うことができますが、この余分な複雑さと混乱します。

Answer 1

これはお探しですか？

template<class T> T add(T X, T Y) 
{ 
    return X + Y; 
} 

または、addのようなものを探していますか？

int x = Apply(2, 4, add<int>); 

Answer 2

私は少し混乱しています...あなたの擬似コードで、なぜ型分化：経由で呼び出され

template<class T, class F> 
T Apply(T x, T y, F f) 
{ 
    return f(x, y); 
} 

？

C++のテンプレートは、テンプレートの完全な型推論を許可：

ここ

template <typename T, typename F> 
T function(T x, T y, F op) { 
    return op(x, y); 
} 

、Fは()関数呼び出し構文と呼ばれ、正確に2種類Tの引数（または暗黙的に受諾することができるもの（特に関数）をフィットそれに変換可能）。

Answer 3

私はあなたがStrategy Patternを探していると思います。

Answer 4

私はあなたの質問にこの意味varが何を意味するのか分かりません。確かに有効なC++キーワードではないので、boost:anyのようなタイプだと仮定します。また、関数に結果の型がありません。私は別のvarを追加しました。あなたの解は、次のようになります。

面白いテンプレート引数はテンプレートそのものであり、その名前は "テンプレートテンプレート引数"です。インスタンスではなく、テンプレートの名前を渡します。それはあなたがstd::plus、ないstd::plus<int>を渡し、次のとおりです。

return function(a, b, std::plus); 

Answer 5

テンプレート関数は、テンプレート引数として渡すことはできません。別のテンプレート関数に渡す前に、この関数のテンプレート引数を手動で推論する必要があります。

template<typename F, typename T> 
T callFunc(T a, T b, F f) 
{ 
    return f(a, b); 
} 

あなたは単にあなたが

int a = callFunc(1, 2, sum<int>); 

を記述する必要が

int a = callFunc(1, 2, sum); 

を書き込むことはできません：たとえば、あなたがcallFuncにそれを渡したい機能

T sum(T a, T b) 
{ 
    return a + b; 
} 

を持っています

渡すことができるようにするsumを書くことなく書かなければならないので、あなたのテンプレート関数を呼び出すfunctor-structまたはclassをoperator（）で書く必要があります。次に、このファンクタをテンプレート引数として渡すことができます。ここに例があります。

template<class T> 
T sum(T a, T b) 
{ 
    return a + b; 
} 
template<class T> 
struct Summator 
{ 
    T operator()(T a, T b) 
    { 
     return sum<T>(a, b); 
    } 
}; 
template<template<typename> class TFunctor, class T> 
T doSomething(T a, T b) 
{ 
    return TFunctor<T>()(a, b); 
    //Equivalent to this: 
    //TFunctor<T> functor; 
    //return functor(a, b); 
} 


int main() 
{ 
    int n1 = 1; 
    int n2 = 2; 
    int n3 = doSomething<Summator>(n1, n2); //n3 == 3 
    return 0; 
} 

Answer 6

私はこれにラムダを使用します。

auto add = [](const auto& lhs, const auto& rhs) { 
    static_assert(std::is_arithmetic<typename std::decay<decltype(lhs)>::type>::value, 
      "Needs to be arithmetic."); 
    static_assert(std::is_arithmetic<typename std::decay<decltype(rhs)>::type>::value, 
      "Needs to be arithmetic."); 
    return lhs + rhs; 
}; 

template<typename LHS, typename RHS, typename FUNC 
    , typename OUT = typename std::result_of<FUNC(LHS, RHS)>::type> 
constexpr OUT do_arithmetic(LHS lhs, RHS rhs, FUNC func) { 
    return func(lhs, rhs); 
} 

constexpr auto t = do_arithmetic(40, 2, add); 
static_assert(t == 42, "Wrong answer!"); 
static_assert(std::is_same<std::decay<decltype(t)>::type, int>::value, 
     "Should be int.");