Deduzione della funzione

Question

Diciamo che abbiamo un modello di classe come questo:

template<typename F> 
class A 
{ 
public: 
    template<typename... Args> 
    A(F f, Args... args) 
    { /* Do something... */ } 
}; 

E ora voglio usare in qualche modo simile a questo:

A<int(int)> a(::close, 1); 

Ora la domanda è: c'è un modo per omettere lo <int(int)> perché un compilatore può conoscere queste informazioni per lo ::close? Non è necessario salvare il "design" del modello.

Per quanto riguarda il compito concreto, ho bisogno di progettare un modello di una classe. Gli oggetti di questa classe potrebbero prendere una funzione e parametri per questa funzione in fase di costruzione e chiamare questa funzione in un secondo momento.

Answer 1

No, non è possibile (al momento). Il modo standard di fare questo è attraverso la creazione di funzione "make_like" (come ad esempio make_pair, make_optional ...):

template<typename F, typename... Args> 
A<std::decay_t<F>> make_A (F &&f, Args&&... args) { 
    return {std::forward<F>(f), std::forward<Args>(args)...}; 
} 

C++ 17 introdurrà template argument deduction for class che vi permetterà di fare esattamente quello che vuoi.

Answer 2

Non è possibile omettere gli argomenti di una classe modello, a meno che non siano predefiniti. Quello che puoi fare è avere una funzione maker che deduce l'argomento e inoltra questo argomento alla classe template, restituendo un oggetto dell'istanza appropriata.

template<typename F, typename... Args> 
A<F> make_A(F f, Args&&... args) { 
    return A<F>(f, std::forward<Args>(args)...); 
} 

Answer 3

Grazie all'adozione del modello di parametri detrazione per i costruttori, in C++ 17, sarete in grado di scrivere solo:

A a(::close, 1); 

Prima di allora, ti basta scrivere una fabbrica per fare la detrazione per voi:

template <class F, class... Args> 
A<std::decay_t<F>> make_a(F&& f, Args&&... args) { 
    return {std::forward<F>(f), std::forward<Args>(args)...}; 
} 

auto a = make_a(::close, 1); 

Questo è un po 'prolisso, ma almeno non è necessario preoccuparsi di efficienza - non ci saranno copie fatte qui grazie alla RVO.