Hipotéticas, ex-C ++ 0x conceitos perguntas

Question

( Preâmbulo: Eu sou um seguidor tarde para o jogo C ++ 0x ea controvérsia recente sobre a remoção de conceitos do padrão C ++ 0x tem me motivou a aprender mais sobre eles. Embora compreenda que todas as minhas perguntas são completamente hipotética - na medida em que os conceitos não será código válido C ++ para algum tempo para vir, se em tudo - eu ainda estou interessado em aprender mais sobre conceitos, especialmente dada a forma como ele iria ajudar me entender melhor os méritos por trás da recente decisão ea controvérsia que se seguiu)

Depois de ter lido algum material introdutório sobre conceitos como C ++ 0x (até recentemente) propôs-los, eu estou tendo problemas envolvendo minha mente em torno de algumas questões sintáticas. Sem mais delongas, aqui estão as minhas perguntas:

1) Será que um tipo que suporta um conceito derivado particular (de forma implícita, através da palavra-chave auto, ou explicitamente via concept_maps) também precisa apoiar o conceito de base indepdendently? Em outras palavras, faz o ato de derivar um conceito de outro (por exemplo concept B<typename T> : A<T>) incluem implicitamente um 'invisível' requer declaração (dentro B, requires A<T>;)? A confusão surge a partir da página da Wikipedia sobre conceitos que afirma:

Como na herança de classe, tipos que atender às exigências do derivado conceito também satisfazer os requisitos de o conceito base.

Isso parece dizer que um tipo só precisa de satisfazer os requisitos do conceito derivado e não necessariamente os requisitos do conceito de base, que não faz sentido para mim. Eu entendo que a Wikipedia está longe de ser uma fonte definitiva; é a descrição acima apenas uma má escolha de palavras?

2) Pode um conceito que listas typenames ser 'auto'? Se assim for, como é que o compilador mapear essas typenames automaticamente? Se não, existem outras ocasiões em que seria inválido para uso 'auto' em um conceito?

Para esclarecer, considere o seguinte código hipotética:

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

seria ou uma dessas classes corresponde SomeType? Ou é um concept_map necessária para conceitos que envolvem typenames?

3) Finalmente, eu estou tendo dificuldade em entender o que axiomas seriam autorizados a definir. Por exemplo, eu poderia ter um conceito definir um axioma que é logicamente inconsistente, como

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

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

O que isso faria? É que mesmo válido?

Eu aprecio que este é um tempo muito longo conjunto de perguntas e então eu agradeço antecipadamente.

Answer 1

Eu usei a recente C ++ 0x projecto mais, N2914 (que ainda tem conceitos redação nele) como referência para a resposta seguinte.

1) Conceitos são como interfaces em que. Se o seu tipo suporta um conceito, ele também deve apoiar todos os conceitos "base". Wikipedia declaração que você cita faz sentido do ponto de vista do cliente de um tipo - se ele sabe que satisfaz T conceito Derived<T>, então ele também sabe que satisfaz conceito Base<T>. Do tipo de perspectiva autor, isto significa, naturalmente, que ambos têm de ser implementadas. Veja 14.10.3 / 2.

2) Sim, um conceito com os membros typename pode ser auto. Tais membros podem ser deduzidos automaticamente se eles são usados ??nas definições de membros de função no mesmo conceito. Por exemplo, value_type para iterador pode ser deduzido como um tipo de retorno de seu operator*. No entanto, se um membro do tipo não é usado em qualquer lugar, não vai ser deduzido, e, portanto, não será definido implicitamente. No seu exemplo, não há nenhuma maneira de SomeType<T>::Type deduzir para qualquer Dummy ou Dummy1, como Type não é usado por outros membros do conceito, então, nem classe irá mapear para o conceito (e, de fato, nenhuma classe poderia possivelmente auto-map a ele). Veja 14.10.1.2/11 e 14.10.2.2/4.

3) Axiomas eram um ponto fraco da especificação, e eles estavam sendo constantemente atualizado para fazer algum) sentido (mais. Pouco antes conceitos foram retirados do projecto, houve uma papel que mudou um pouco - lê-lo e ver se ele faz mais sentido para você, ou você ainda tem dúvida sobre it

.

Para o seu exemplo específico (representando diferença sintática), isso significaria que compilador seria permitido considerar (a*1) expressão a ser o mesmo que (a*2), com a finalidade do "como se" regra da língua (ou seja, o compilador permitido fazer quaisquer otimizações que quer, desde que se comporta de resultados como se não havia nenhum). No entanto, o compilador não é de forma alguma necessário para validar a correção de axiomas (daí por que eles são chamados axiomas!) -. Ele só leva-los para o que são