Passa il puntatore al template come funzione?

Question

Say voglio una funzione ++ C per eseguire operazioni aritmetiche su due ingressi, trattandoli come un dato tipo:

pseudo:

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

funzioni che si adattano OP potrebbero essere come:

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

Quindi, la domanda è: quale sarebbe la firma per la funzione? Se le funzioni dell'operatore non sono basate su modelli, posso farlo, ma mi confondo con questa complessità extra.

Answer 1

Stai cercando questo?

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

O stai cercando qualcosa che chiama qualcosa come aggiungi?

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

chiamata Via:

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

Answer 2

Sono un po 'confuso ... perché il tipo di differenziazione nel pseudo-codice?

modelli C++ consentono tipo detrazione sui modelli:

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

Qui, F si inserisce nulla (soprattutto funzioni) che può essere chiamata con la sintassi chiamata () funzione e accettando esattamente due argomenti di tipo T (o implicitamente convertibile ad esso).

Answer 3

Penso che stiate cercando lo Strategy Pattern.

Answer 4

Non sono sicuro di cosa significhi questa cosa var nella tua domanda. Non è certamente una parola chiave C++ valida, quindi presumo sia un tipo simile a boost:any. Inoltre, la funzione non ha un tipo di risultato. Ho aggiunto un altro var, qualunque cosa potrebbe essere. La vostra soluzione potrebbe essere la seguente:

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

L'argomento divertente modello è un modello di per sé, da cui il nome "template argomento". Passi nel nome di un modello, non in un'istanza. Cioè, si passa std::plus, non std::plus<int>:

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

Answer 5

funzioni dei modelli non possono essere passati come argomenti di template. È necessario dedurre manualmente gli argomenti del modello per questa funzione prima di passarla a un'altra funzione del modello.Ad esempio, la funzionalità dei

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

Si vuole passarlo a callfunc:

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

Non si può semplicemente scrivere

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

Devi scrivere

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

Per essere in grado di passare sum senza scrivere int, devi scrivere un functor - struct o class con operator() che chiamerà la tua funzione template. Quindi puoi passare questo functor come argomento del template. Ecco un esempio.

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

Io uso lambda per questo.

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.");