Domande di concetti ipotetici, precedentemente C ++ 0x

Question

( Preambolo: sono un seguace in ritardo del gioco C ++ 0x e la recente controversia relativa alla rimozione di concetti dallo standard C ++ 0x mi ha motivato a saperne di più su di essi. Mentre capisco che tutte le mie domande sono completamente ipotetiche - nella misura in cui i concetti non saranno codice C ++ valido per un po 'di tempo a venire, se non altro - sono ancora interessato a saperne di più sui concetti, soprattutto dato che sarebbe utile Comprendo meglio i meriti alla base della recente decisione e delle controversie che sono seguite)

Dopo aver letto del materiale introduttivo su concetti come C ++ 0x (fino a poco tempo fa) li ha proposti, ho problemi a avvolgere la mia mente attorno ad alcuni problemi sintattici. Senza ulteriori indugi, ecco le mie domande:

1) Un tipo che supporta un particolare concetto derivato (implicitamente, tramite la parola chiave auto o esplicitamente tramite concept_maps) dovrebbe anche supportare il concetto di base in modo indipendente? In altre parole, l'atto di derivare un concetto da un altro (ad es. concept B<typename T> : A<T>) include implicitamente un'istruzione "invisibile" richiede (all'interno di B, requires A<T>;)? La confusione sorge dalla pagina di Wikipedia su concetti che affermano:

  

Come nell'eredità di classe, digita quello   soddisfare i requisiti del derivato   il concetto soddisfa anche i requisiti di   il concetto di base.

Questo sembra dire che un tipo deve solo soddisfare i requisiti del concetto derivato e non necessariamente i requisiti del concetto base, il che non ha senso per me. Capisco che Wikipedia è tutt'altro che una fonte definitiva; la descrizione sopra è solo una cattiva scelta di parole?

2) Un concetto che elenca i nomi dei caratteri può essere "auto"? In tal caso, come dovrebbe il compilatore mappare automaticamente questi nomi di tipo? In caso contrario, ci sono altre occasioni in cui non sarebbe valido utilizzare "auto" su un concetto?

Per chiarire, considera il seguente codice ipotetico:

template<typename Type>
class Dummy {};

class Dummy2 { public: typedef int Type; };

auto concept SomeType<typename T>
{
     typename Type;
}

template<typename T> requires SomeType<T>
void function(T t)
{}

int main()
{
    function(Dummy<int>()); //would this match SomeType?
    function(Dummy2()); //how about this?
    return 0;
}

Una di queste classi corrisponderebbe a SomeType? O è necessaria una concept_map per i concetti che coinvolgono i nomi dei caratteri?

3) Infine, faccio fatica a capire quali assiomi sarebbero autorizzati a definire. Ad esempio, potrei avere un concetto per definire un assioma che è logicamente incoerente, come

concept SomeConcept<typename T>
{
    T operator*(T&, int);

    axiom Inconsistency(T a)
    {
         a * 1 == a * 2;
    }
} 

Cosa farebbe? È anche valido?

Apprezzo che questa sia una serie di domande molto lunga e quindi ti ringrazio anticipatamente.

Answer 1

Ho usato la più recente bozza C ++ 0x, N2914 (che contiene ancora una formulazione dei concetti) come riferimento per la seguente risposta.

1) I concetti sono come interfacce in questo. Se il tuo tipo supporta un concetto, dovrebbe anche supportare tutto & Quot; base & Quot; concetti. L'affermazione di Wikipedia che citi ha senso dal punto di vista del cliente di un tipo - se sa che T soddisfa il concetto Derived<T>, allora sa anche che soddisfa il concetto Base<T>. Dal punto di vista dell'autore del tipo, ciò significa naturalmente che entrambi devono essere implementati. Vedi 14.10.3 / 2.

2) Sì, un concetto con typename membri può essere auto. Tali membri possono essere dedotti automaticamente se vengono utilizzati nelle definizioni dei membri di funzione nello stesso concetto. Ad esempio, value_type per iteratore può essere dedotto come tipo di ritorno del suo operator*. Tuttavia, se un membro del tipo non viene utilizzato da nessuna parte, non verrà dedotto e quindi non sarà definito in modo implicito. Nel tuo esempio, non c'è modo di dedurre SomeType<T>::Type per Dummy o Dummy1, poiché Type non è utilizzato da altri membri del concetto, quindi nessuna classe verrà mappata al concetto (e, di fatto, , nessuna classe potrebbe mapparsi automaticamente). Vedi 14.10.1.2/11 e 14.10.2.2/4.

3) Gli assiomi erano un punto debole delle specifiche e venivano costantemente aggiornati per dare un senso (più). Poco prima che i concetti venissero estratti dalla bozza, c'era un paper che è cambiato un po '- leggilo e vedi se ha più senso per te, o hai ancora domande al riguardo.

Per il tuo esempio specifico (tenendo conto della differenza sintattica), significherebbe che al compilatore sarebbe consentito considerare l'espressione (a*1) uguale a (a*2), ai fini della quotazione &; come se " regola del linguaggio (vale a dire al compilatore autorizzato a fare tutte le ottimizzazioni che desidera, purché il risultato si comporti come se non ce ne fossero). Tuttavia, il compilatore non è in alcun modo necessario per convalidare la correttezza degli assiomi (quindi perché sono chiamati assiomi!) - li prende semplicemente per quello che sono.