opérateur = (T * r) dans les modèles imbriqués

Question

J'ai un problème concernant les modèles imbriqués et le remplacement de l'opérateur d'affectation. Dites que je veux avoir une référence de modèle de classe refcounting _reference. Cette référence pour l'instant simplement détient un pointeur sur l'objet compté ref. Le problème est que tout cela fonctionne bien, aussi longtemps que je fais cela avec des classes simples ou des structures. par exemple. _référence ...,

Mais maintenant, je veux créer un modèle de classe qui fasse référence à un vecteur std transmettant la classe qu'il contient.

Non, je viens juste de poster le code: (ça ne fait pas de refcounting et ce genre de choses pour le moment, c’est juste l’extraction du problème que j’ai)

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)

Erreur GCC:

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>)))'

Alors, s'il vous plaît, quelqu'un peut-il m'expliquer pourquoi l'opérateur d'affectation ne fonctionne pas ici, alors que la fonction simplySetIt le fait?

Answer 1

L'opérateur de base = est masqué par les opérateurs d'assignation implicites, de sorte qu'il ne participe plus à la surcharge. Vous devez écrire _ref_vector sous

.

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

Comme il n'y a pas de version de simplySetIt ajoutée par le compilateur, Lookup la trouvera dans la classe de base.

Answer 2

Comme le dit la norme (13.5.3):

Puisqu’un opérateur d’attribution de copie operator = est implicitement déclaré pour une classe si non déclarée par l'utilisateur (12.8), une affectation de classe de base opérateur est toujours masqué par l'opérateur d'affectation de copie du classe dérivée.