constructeur de copie est implicitement supprimé parce que la définition par défaut serait mal formé

J'ai une classe A (à partir d'une bibliothèque sur laquelle je n'ai aucun contrôle) avec un constructeur de copie et un clone méthode, et une classe B dérivé de A. Je tiens à mettre en œuvre clone pour B ainsi.

L'approche naïve

#include <memory>

class A { //I have no control here
  public:
    A(int a) {};

    std::shared_ptr<A>
      clone() const
      {
        return std::shared_ptr<A>(new A(*this));
      }

  private:
    A(const A & a) {};
};

class B: public A {
  public:
    B(int data, int extraData):
      A(data),
      extraData_(extraData)
    {
    }

    std::shared_ptr<B>
    clone() const
    {
      return std::shared_ptr<B>(new B(*this));
    }

  private:
    int extraData_;
};

int main() {
  A a(1);
}

cependant, ne parvient pas, depuis le constructeur de copie de A est privé:

main.cpp: In member function ‘std::shared_ptr<B> B::clone() const’:
main.cpp:27:42: error: use of deleted function ‘B::B(const B&)’
     return std::shared_ptr<B>(new B(*this));
                                      ^
main.cpp:17:7: note: ‘B::B(const B&)’ is implicitly deleted because the default definition would be ill-formed:
 class B: public A {
       ^
main.cpp:14:5: error: ‘A::A(const A&)’ is private
     A(const A & a) {};
     ^
main.cpp:17:7: error: within this context
 class B: public A {

Il pourrait y un moyen de rendre l'utilisation de A::clone() pour B::clone(), mais je ne suis pas sûr de savoir comment cela fonctionnerait exactement. Un indice?

InformationsquelleAutor Nico Schlömer | 2015-06-05

c++clone copy-constructor private-constructor

4

Je présume que c'est une faute de frappe que votre B n'a pas de membres du public à tous,
et que vous êtes absent une public: avant la définition de B::B(int,int).

L'auteur de la classe représentée par votre A veut apparemment à être
clonable, mais pas de copie constructible. Qui laisserait à penser qu'il ou elle veut que tous les
les instances de vivre sur le tas. Mais, au contraire, il y a le public
constructeur A::A(int). Êtes-vous sûr que vous avez raison à ce sujet?

Il est plausible de supposer que la classe peut révéler assez d'informations
sur une instance donnée constituent un autre exemple. E. g., mettre
un peu plus de chair sur A:
```
class A {
public:
    A(int a) 
    : data_(a){};

    std::shared_ptr<A>
    clone() const
    {
        return std::shared_ptr<A>(new A(*this));
    }

    int data() const {
        return data_;
    }

private:
    A(const A & a) {};
    int data_;
};
```
Et si cela est vrai, alors le constructeur public rendrait simplement
pas pratique pour contourner le privé, undefined constructeur de copie:
```
A a0(1);
A a1{a0.data()};     //Inconvenient copy construction
```
Donc je suis moins certain que A représente fidèlement le problème
classe. En le prenant à la valeur nominale, cependant, la question que vous devez répondre
est: Pouvez-vous encore malencontreusement copie de construire un A?

Si non, alors vous êtes coincé. Si oui, alors vous pouvez utiliser dérange copie
la construction de A expressément définir un classique de constructeur de copie pour B,
ce qui est tout ce dont vous avez besoin. E. g.
```
class B: public A {
public:
    B(B const & other)
    : A(other.data()),extraData_(other.extraData_){}    

    B(int data, int extraData):
    A(data),
    extraData_(extraData)
    {
    }

    std::shared_ptr<B>
    clone() const
    {
        return std::shared_ptr<B>(new B(*this));
    }

    int extradata() const {
        return extraData_;
    }

private:
    int extraData_;
};

#include <iostream>

int main()
{
    B b(1,2);
    std::shared_ptr<B> pb = b.clone();
    std::cout << pb->data() << std::endl;
    std::cout << pb->extradata() << std::endl;
    return 0;
} 
```
InformationsquelleAutor Mike Kinghan
2

Vous avez besoin de faire le constructeur par copie de A protégés de façon à ce que la classe dérivée peut l'utiliser:
```
protected:
    A(const A & a) { /*...*/ }
```
Espère que ça aide.
- Je n'ai pas de contrôle sur A puisqu'il provient d'une bibliothèque; j'ai expliqué cela dans le post original.
- Ensuite, vous ne devriez pas être découlant de A.
- Ohh.. dans ce cas, c'est une mauvaise idée de dériver de A. Vous devez utiliser la composition maintenant, au lieu de l'héritage.
- C'est une mauvaise idée de dériver de A à tous. Avoir un (et omis) constructeur de copie est un assez gros soupçon de la part du développeur que de choses diverses - y compris à l'aide de A comme une classe de base - sont découragés.
- C'est qu'une règle générale: "Ne pas dériver de classes avec la copie privée, les constructeurs"? Je ne comprends pas très bien pourquoi maintenant.
- Si le copier-ctor est privé, alors cela signifie que PERSONNE, pas même dérivée de la classe, est autorisé à faire une copie des objets de cette classe. Cela signifie, vous ne pouvez pas tirer et dans le même temps, faire copable/clonable. Si vous voulez en tirer, alors vous à faire la classe dérivée non-copable/non-clonable dans.
InformationsquelleAutor Nawaz
1

La raison pour laquelle la définition par défaut de Bs'constructeur de copie est mal formé est parce que - si elle était autorisée - elle invoque le privé (donc inaccessible à B) et n'est pas définie constructeur de copie de A.

Faire As'constructeur de copie soit protégé ou public, de sorte qu'il est accessible à B. Un autre (très mauvais) option consiste à déclarer la classe B comme un ami de A. Toutes les possibilités sont également vous demander de fournir une définition pour As'constructeur de copie.
- Je n'ai pas de contrôle sur Un puisqu'il provient d'une bibliothèque; j'ai expliqué cela dans le post original.
- Selon les commentaires que j'ai fait en réponse à cette clarification (ci-dessous Nawaz post) avoir un constructeur privé est assez significative de l'indice que vous ne devriez pas être découlant de A.
- Il n'y a pas moyen de rendre l'utilisation de A::clone() soit?
InformationsquelleAutor Peter

Vous devez vous connecter pour publier un commentaire.