Cosa sono i modelli vincolati?

Question

Herb Sutters ha menzionato i modelli vincolati (a.k.a. Concepts Lite) nel talk: Modern C++: What You Need to Know.

So che boost ha un pacchetto di concetti in uso da anni, che consente di stampare abbastanza messaggi di errore, quando il meccanismo di deduzione del modello non riesce a trovare operatori, funzioni o ha schemi di violazione di accesso.

Ho riscontrato menzioni sul isocpp blog che esiste già un ramo sperimentale di gcc che implementa lo document proposing Concepts Lite. Tuttavia guardando attraverso l'attuale C++14 draft non sono riuscito a trovare alcun suggerimento se questo sarà già parte di C++14.

Quindi le domande sono semplici:

• sarà Concetti Lite far parte di C++ 14? (Riferimento nello standard preferito. Non riuscivo a trovarne uno, e non ho molta familiarità con lo standard.)
• qual è la sintassi corretta di esso? (La proposta e le diapositive di Herb divergono qui e non so quale sia più aggiornato)
• potresti fornire un esempio minimo di un vincolo (predicato) e un modello vincolato?

NOTA: se si aspetta abbastanza a lungo Cercherò di ottenere il gcc ramo esecuzione e posso almeno dire nulla circa l'attuazione sperimentale, che però non implica la correttezza della sintassi.

Answer 1

Concepts Lite è la parte "vincoli" di un progetto di concetti completo per C++. È descritto dettagliatamente in N3701 "Concepts Lite". Il Capitolo 2 è un breve tutorial che esegue rapidamente i principi fondamentali e la loro applicazione, il che è ottimo per chi non vuole leggere tutte le 56 pagine.

Concepts Lite non farà parte di C++ 14, verrà rilasciato come Specifica tecnica separata entro la fine dell'anno. L'ultima bozza di massima per la formulazione di TS è N3929 "Concepts Lite Specification".

Esistono diverse varianti di sintassi dei vincoli. L'esempio di codice che Herb usato nel colloquio:

auto mean(const Sequence& seq) { 
    auto n = 0.0; 
    for (auto x : seq) 
    n += x; 
    return n/seq.size(); 
} 

viene indicato come il "Sintassi laconico" in quanto si tratta di un equivalente più breve della sintassi verbose:

template <typename __T> 
    requires Sequence<__T>() 
auto mean(const __T& seq) { 
    auto n = 0.0; 
    for (auto x : seq) 
    n += x; 
    return n/seq.size(); 
} 

Entrambi indicano che il modello di funzione mean può essere istanziato con qualsiasi tipo che modella il concetto Sequence. Per semplicità, supponiamo che i requisiti per Sequence siano solo quelli che la nostra implementazione di mean richiede: (a) membri begin & end che restituiscono gli iteratori e (b) funzione membro size che restituisce un tipo integrale. Potremmo definire il concetto come:

template <typename T> 
concept bool Sequence() { 
    return requires(T t) { 
    {t.size()} -> Integral; 
    {t.begin()} -> InputIterator; 
    {t.end()} -> InputIterator; 
    requires Same<decltype(t.begin()), decltype(t.end())>(); 
    } 
} 

assumendo definizioni straight-forward di Integral, InputIterator e Same.Questa definizione concetto garantisce che, per un valore inventato t del tipo T in prova:

• t.size() è un'espressione valida, e restituisce un tipo che modella il concetto Integral.
• t.begin() è valido e restituisce un tipo che modella InputIterator.
• Uguale a t.end().
• Il InputIterator restituito da t.begin() ha lo stesso tipo di quello restituito da t.end().