Передать указатель-в-шаблон-функцию в качестве аргумента функции?

Question

Скажем, я хочу Си ++ для выполнения арифметических операций над двумя входами, рассматривая их в качестве данного типа:

псевдо:

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; 
} 

Или вы ищете что-то, что называет что-то вроде добавления?

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

Вызывается через:

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

Answer 2

Я немного запутался ... почему тип дифференциации в вашем псевдо-коде?

шаблоны C++ позволяют полный тип вычет на шаблонах:

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

Здесь F подходит что-нибудь (особенно функции), которые могут вызываться с синтаксисом вызова в () функции и принимать ровно два аргумента типа T (или неявно конвертируемый в него).

Answer 3

Я думаю, что вы ищете Strategy Pattern.

Answer 4

Я не уверен, что это var вещь в вашем вопросе означает. Это, конечно, не допустимое ключевое слово C++, поэтому я предполагаю, что это тип, похожий на boost:any. Кроме того, в функции отсутствует тип результата. Я добавил еще var, что бы это ни было. Ваше решение может выглядеть следующим образом:

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

смешной аргумент шаблона является сам шаблон, отсюда и его название «шаблон аргумент шаблона». Вы передаете имя шаблона, а не экземпляр. То есть, вы передаете std::plus, а не std::plus<int>:

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

Answer 5

функция шаблон не может быть передана в качестве аргументов шаблона. Вы должны вручную вывести аргументы шаблона для этой функции, прежде чем передавать ее в другую функцию шаблона.Например, у вас есть функция

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

Вы хотите передать его callFunc:

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

Вы не можете просто написать

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

Вы должны написать

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

Для пропуска sum без записи int, вы должны написать 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.");