C++ definizione alternativa membro

Question

In C++ è possibile definire membri seguente modo:

struct test { 
    using memberType = int(int); 
    /*virtual*/ memberType member; 
}; 

int test::member(int x) { return x; } 

Con C++ 14 v'è alcun modo per definire l'elemento all'interno della definizione di classe, per esempio con un lambda?

Answer 1

non credo che sia possibile, ma si potrebbe fare se il membro è un puntatore a funzione

struct test { 
    int (*member)(int) = [](int x){return x;}; 
}; 

dal momento che una lambda con una lista di acquisizione vuoto è in realtà una funzione regolare

Answer 2

Il unico modo ho potuto pensare a noi di usare un oggetto std::function<>, ma si deve passare l'istanza (non riesco a pensare a come potrebbe essere legato automaticamente ..)

struct foo { 
    using T = int(foo&, int); 

    int b; 
    std::function<T> x = [](foo& f, int a) { return a * f.b; }; 
}; 

Answer 3

stai cercando di scrivere qualcosa del genere:

struct test { 
    auto member_impl = [this]() { 
    }; 
}; 

questo non riesce a (almeno) tre conteggi:

1. Non è possibile dichiarare un membro non statico auto.

2. Non è possibile assegnare un nome del tipo di un lambda (quindi deve essere automatica)

3. this non è disponibile al momento della definizione della classe.

Risposta breve, no.

ma si può scrivere:

struct test { 
    auto member_impl() { 
    }; 
}; 

che è di circa il più breve, come si arriva.

Answer 4

Credo 5.1.5/3 è quello che impedisce di utilizzare un lambda il modo in cui lo si dovrebbe utilizzare, mi dispiace:

[...] A lambda-espressione non deve comparire in un operando non valutata (Clausola [espr]), in un argomento modello, in una dichiarazione alias, in una dichiarazione typedef, o nella dichiarazione di un modello di funzione o funzione al di fuori del suo corpo della funzione e degli argomenti predefiniti. [Nota: l'intenzione è di impedire che lambda appaia in una firma. - nota end] [...]

Detto questo, C++ 14 vi fa definire un tipo di utente utilizzando i modelli, come nel seguente esempio:

template<typename F> 
struct S; 

template<typename R, typename... Args> 
struct S<R(Args...)> { 
    using member = R(Args...); 
    R operator()(Args...) { return R{}; } 
    member M; 
}; 

template<typename R, typename... Args> 
R S<R(Args...)>::M(Args...) { return R{}; } 

int main() { S<void(int)> s; }