Héritage privé et échange

Question

J'utilise l'héritage privé dans l'implémentation de deux classes très liées. Le using Base::X; est très utile et élégant. Cependant, je n'arrive pas à trouver une solution élégante pour réutiliser la fonction d'échange de la classe de base.

class A 
{ 
public: 
    iterator  begin(); 
    const_iterator begin() const; 
    const_iterator cbegin() const; 

    A clone(); 

    void swap(A& other); 
}; 

class Const_A : private A 
{ 
public: 
    // I think using A::A; will be valid in C++0x 
    Const_A(const A& copy) : A(copy) { } 

    // very elegant, concise, meaningful 
    using A::cbegin; 

    // I'd love to write using A::begin;, but I only want the const overload 
    // this is just forwarding to the const overload, still elegant 
    const_iterator begin() const 
    { return A::begin(); } 

    // A little more work than just forwarding the function but still uber simple 
    Const_A clone() 
    { return Const_A(A::clone()); } 

    // What should I do here? 
    void swap(Const_A& other) 
    { /* ??? */ } 
}; 

Jusqu'à présent, la seule chose que je peux trouver est copier-coller « la définition de Const_A::swap dans » A::swap définition s, beurk!

Existe-t-il une solution élégante pour réutiliser le swap de la classe de base privée?

Existe-t-il une façon plus simple d'implémenter ce que j'essaie de faire ici (un wrapper const pour une classe)?

Answer 1

Eh bien, ne pouvez-vous pas simplement appeler la version de base de swap?

void swap(Const_A& other) 
{ 
    A::swap(other); // swaps the `A` portion of `this`. 
    // … 
} 

Au lieu de …, vous auriez normalement échanger les membres ne concernant que Const_A, non A mais comme il n'y en a pas dans votre cas particulier, cela est tout ce que vous avez besoin.

Answer 2

Vous pouvez faire comme avec le reste des méthodes:

void Const_A::swap(Const_A& other) { 
    A::swap(other); 
    // here any specifics 
}