Quais são membros não-template C ++ como usado no truque Barton-Nackman?

votos
0

De Wikipedia:

// A class template to express an equality comparison interface.
template<typename T> class equal_comparable
{
    friend bool operator==(T const &a, T const &b) { return  a.equal_to(b); }
    friend bool operator!=(T const &a, T const &b) { return !a.equal_to(b); }
};

class value_type
// Class value_type wants to have == and !=, so it derives from
// equal_comparable with itself as argument (which is the CRTP).
     : private equal_comparable<value_type>
{
public:
    bool equal_to(value_type const& rhs) const; // to be defined
};

Isto é suposto ser a Barton-Nackman , que poderia conseguir tempo de compilação análise dimensional (verificando se algumas operações aplicado a variáveis acabar em números comparáveis, como a velocidade comparável ao espaço / tempo, mas sem aceleração).

Alguém poderia me explicar como, ou pelo menos me explicar o que são os membros não-modelo?

obrigado

Publicado 19/05/2009 em 15:25
fonte usuário
Em outras línguas...                            


3 respostas

votos
4

As regras da língua mudaram desde que o padrão foi inventado, embora cuidado foi tomado para não quebrá-lo. Em outras palavras, tanto quanto eu posso dizer, ele ainda funciona, mas por razões diferentes do que originalmente fez. Eu não acho que eu iria basear uma tentativa de análise dimensional sobre este padrão como eu acho que há melhores maneiras de fazer isso hoje.

Eu também acho que o exemplo é trivial demais para ser útil. Como já foi dito a instanciação de equal_comparable<value_type>causas operator==e operator!=para value_typea aparecer. Uma vez que eles são não-membros, não importa que a herança é privado, eles ainda estão eligable para seleção ao resolver uma chamada. É apenas difícil ver o ponto neste exemplo. Vamos dizer no entanto, que você adicionar um parâmetro de modelo para equal_comparablee algumas outras coisas:

template<typename U, typename V> class equal_comparable
{
    friend bool operator==(U const &a, V const &b) { return  a.equal_to(b); }
    friend bool operator!=(U const &a, V const &b) { return !a.equal_to(b); }
};

class some_other_type 
{
    bool equal_to(value_type const& rhs) const;
};

class value_type
: private equal_comparable<value_type>,      // value_type comparable to itself
  private equal_comparable<some_other_type>  // value_type comparable to some_other_type
{
public:
    bool equal_to(value_type const& rhs) const;
    bool equal_to(some_other_type const& rhs) const;
};

Disclaimer: Eu não tenho idéia se essa é a maneira que é suposto para ser usado, mas estou razoavelmente certo de que ele iria trabalhar como descrito.

Respondeu 19/05/2009 em 23:14
fonte usuário

votos
1

A instanciação equal_comparable<value_type>em value_typeclasse faz com que o compilador para gerar duas funções de comparação:

friend bool operator==(value_type const &a, value_type const &b) { return  a.equal_to(b); }
friend bool operator!=(value_type const &a, value_type const &b) { return !a.equal_to(b); }

Estas funções são nontemplate uma vez que não depende de qualquer parâmetro do modelo, mas eles também são não-membros, uma vez que são declarados como friend.

Respondeu 19/05/2009 em 16:10
fonte usuário

votos
1

Estes são realmente não associados sem modelo - os operadores de comparação no modelo base - que se acostumar pelo ADL para a classe derivada. Um membro de modelo seria algo como:


class C
{
    ...
    template < typename T > void DoGreatStuff( T t ) { ... }
    ...
};
Respondeu 19/05/2009 em 15:57
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more