= Operador (T * r) em modelos aninhados

Question

Eu tenho um problema relativo modelos aninhados e substituindo do operador de atribuição. Digamos que eu queira ter um _reference modelo de classe refcounting. Este _reference por agora simplesmente contém um apontador para o objecto contou-rep. O problema agora é que tudo isso funciona bem, enquanto estou fazendo isso com classes simples ou estruturas. por exemplo. _reference ...,

Mas agora eu quero fazer um modelo de classe que é uma referência a um std-vector encaminhar a classe que detém.

Não, eu só postar o código: (ele não se refcounting e que coisas agora, é apenas a extração do problema que tenho)

template <typename T>
class _reference
{
private:
    T* p_;

public:

// !!! this assignment seems only to work, when T is no class template already...
void operator= (T* r)                   
{
    p_ = r;
}

// WHILE this ALWAYS works as well...
void simplySetIt (T* r)                 
{
    p_ = r;
}
};

template <typename T>
class _ref_vector : public _reference<vector<T> >
{
};

void test2 ()
{
_reference<vector<long> > ref_ptr2;
_ref_vector<long>         ref_ptr3;

ref_ptr2 = new vector<long>;                    // works fine.

ref_ptr3 = new vector<long>;                // BUT: THIS doesnt work
    ref_ptr3.simplySetIt (new vector<long>);    // WHILE: this works fine...
}

MSVC-Error:

error C2679: binary '=' : no operator found which takes a right-hand operand of type 
'std::vector<_Ty> *' (or there is no acceptable conversion)

GCC-Erro:

error: no match for 'operator=' in 'ptr3 = (((const stlp_std::allocator<long int>&)
((const stlp_std::allocator<long int>*)(& stlp_std::allocator<long int>()))), 
(((stlp_std::vector<long int, stlp_std::allocator<long int> >*)operator new(12u)), 
((<anonymous> != 0u) ? (<anonymous>->stlp_std::vector<_Tp, _Alloc>::vector [with 
_Tp = long int, _Alloc = stlp_std::allocator<long int>]
(<anonymous>), <anonymous>) : <anonymous>)))'

Então, por favor, alguém pode me explicar por que a atribuição operador não trabalha aqui, enquanto o simplySetIt -? Função faz

Answer 1

O operador base = fica escondido por operadores de atribuição implícitas, de modo que não participa na mais sobrecarga. Você precisa _ref_vector escrita como

template <typename T>
class _ref_vector : public _reference<vector<T> >
{
  using _reference<vector<T> >::operator=;
};

Como não há nenhuma versão de compilador adicional de simplySetIt, pesquisa vai encontrá-lo na classe base.

Answer 2

Como o padrão diz (13.5.3):

Como um operador de operador de atribuição de cópia = é implicitamente declarado para uma classe se não for declarado pelo utilizador (12,8), uma atribuição de classe de base operador está sempre escondido pelo operador de atribuição cópia do classe derivada.