Copier le constructeur avec des pointeurs

J'ai récemment découvert que quand j'ai des pointeurs à l'intérieur d'une classe, j'ai besoin de spécifier un constructeur de Copie.

De l'apprendre, j'ai fait le code simple suivant. Il compile, mais me donne l'erreur d'exécution lors de l'exécution du constructeur de copie.

Je suis en train de copier la valeur du pointeur de l'objet copié, mais en évitant l'attribution de la même adresse.

Alors, quel est le problème ici?

    class TRY{
        public:
        TRY();
    ~TRY();
        TRY(TRY const &);

        int *pointer;

        void setPointer(int);
    };


    void TRY::setPointer(int a){
        *pointer = a;

        return;
    }


    TRY::TRY(){}


    TRY::~TRY(){}


    TRY::TRY(TRY const & copyTRY){
        int a = *copyTRY.pointer;
        *pointer = a;
    }



    int main(){

        TRY a;
        a.setPointer(5);

        TRY b = a;

        b.setPointer(8);

        cout << "Address of object a = " << &a << endl;
        cout << "Address of object b = " << &b << endl;

        cout << "Address of a.pointer = " << a.pointer << endl;
        cout << "Address of b.pointer = " << b.pointer << endl;

        cout << "Value in a.pointer = " << *a.pointer << endl;
        cout << "Value in b.pointer = " << *b.pointer << endl;

        return 0;
    }

Je vais utiliser ce concept pour les autres classes avec beaucoup de pointeurs en elle, où j'ai besoin de copier toutes les valeurs de l'objet à l'autre. La copie est d'abord nécessaire pour ce code, je tiens à garder la copie de possibilité (je ne vais pas cacher le constructeur de copie privée").

D'ailleurs, la vraie classe j'ai besoin de mettre en œuvre, comme les 10 pointeurs, et il pourrait être en train de changer avec le temps. N'est-il pas un peu plus intelligent moyen d'avoir une copie en profondeur constructeur en C++?...

source d'informationauteur Biga | 2009-04-23

  1. 13

    Avec la déclaration int* pointer que vous venez de définir un pointeur, mais n'a pas alloué de la mémoire. D'abord, vous devez faire le point à un bon emplacement de la mémoire par l'allocation de la mémoire comme ceci: int* pointer = new int. Ensuite, dans le constructeur de copie de nouveau, vous devez allouer de la mémoire pour l'objet copié. Aussi, ne pas oublier de libérer la mémoire à l'aide de delete dans le destructeur.

    J'espère que cet exemple permet de:

    class B
{

public:
    B();
    B(const B& b);
    ~B();
    void setVal(int val);

private:
    int* m_p;
};

B::B() 
{
    //Allocate the memory to hold an int
    m_p = new int;

    *m_p = 0;
}

B::B(const B& b)
{
    //Allocate the memory first
    m_p = new int;

    //Then copy the value from the passed object
    *m_p = *b.m_p;
}

B::~B()
{

    //Release the memory allocated
    delete m_p;
    m_p = NULL;
}

void B::setVal(int val)
{
    *m_p = val;
}
  2. 8

    J'ai récemment découvert que lorsque je
    avoir des pointeurs à l'intérieur d'une classe, j'ai besoin de
    pour spécifier un constructeur de Copie.

    Il n'est pas tout à fait vrai. Lorsque vous avez des pointeurs dans votre classe et à allouer de la mémoire à l'aide de new ensuite, vous avez à vous soucier de constructeur de copie. Aussi, n'oubliez pas de l'opérateur d'affectation et destructeur.
    Vous devez supprimer la mémoire allouée à l'aide d' delete.

    Il est appelé La Loi Des Trois Grands.

    Exemple:

      ~Matrix();  //Destructor
  Matrix(const Matrix& m); //Copy constructor
  Matrix& operator= (const Matrix& m); //Assignment operator
  3. 3

    Si vous voulez faire une copie en profondeur, bien sûr, vous devez également allouer de mémoire pour stocker les valeurs. Si l'original est un pointeur vers un int, et vous ne voulez pas la copie d'utiliser la même valeur de pointeur, vous devez allouer de la nouvelle mémoire pour stocker un int, puis copiez la valeur de là.

    Votre exemple n'est pas très claire, il ne montre pas la mise en œuvre de votre constructeur de copie, ou comment le pointer membre est initialisé.

  4. 1

    si il a un pointeur vers un type ordinaire puis

    A::A(const A& a):
  pointer_( new int( *a.pointer_ ) )
{
}

    si il a un pointeur vers une classe de base quelconque, puis

    A::A(const &a ):
  pointer_( a.pointer_->clone() )
{
}

    Clone est une mise en œuvre d'un prototype de modèle

    Ne pas oublier de supprimer le pointeur dans le destructeur

    A::~A()
{
    delete pointer_;
}

    Pour fixer votre exemple

    TRY::TRY(TRY const & copyTRY){
    int a = *copyTRY.pointer;
    pointer = new int(a);
}
  5. 1

    Votre problème est dans cette ligne, ici:

        *pointer = a;

    Tous les trucs qui se passe normalement dans votre constructeur par défaut n'est pas encore arrivé, y compris l'allocation de la mémoire pour *pointer.

    La solution est d'allouer de la mémoire pour un entier. Vous pouvez utiliser malloc et amis ou new pour cela, mais assurez-vous que c'est la même méthode que vous utilisez dans votre constructeur par défaut, parce que vous obtenez seulement un destructeur, et les appels doivent correspondre.

  6. 1

    Si un membre-sage (peu profonde) copie est ok, alors vous n'avez pas à faire quoi que ce soit. Si vous voulez une copie en profondeur, vous devez allouer un nouveau stockage pour des copies de tous les membres.

  7. 1

    J'ai récemment découvert que lorsque je
    avoir des pointeurs à l'intérieur d'une classe, j'ai besoin de
    pour spécifier un constructeur de Copie

    Plus souvent que pas, il est une bonne idée de simplement le désactiver en le déclarant (et de l'affectation de l'opérateur privé et de ne pas la mettre en œuvre.

  8. 0

    Lors de l'écriture d'un Constructeur de Copie, vous devez allouer de la mémoire pour tous les membres.
    Dans votre cas:

    TRY::TRY(TRY const & copyTRY){
    pointer = new int(*(copyTry.pointer));
}

    Opérateur= est en quelque sorte similaire, mais sans l'allocation de mémoire.

    TRY& operator=(TRY const& otherTRY){
      this->a  = *(otherTry.pointer)
      return *this
}
  9. 0

    Plus souvent que pas, si VOUS avez besoin d'écrire un constructeur de copie ou de l'opérateur d'affectation, vous êtes en train de faire quelque chose de mal. Laisser la copie des constructeurs et des opérateurs d'affectation pour les responsables de l'implémentation de la bibliothèque standard. Composez votre classes de déjà-copiable et assignables éléments et vous n'aurez pas à écrire votre propre.

    Par exemple, peut-être que int * membre doit être un std::vector à la place.

    Si vous ne pouvez pas faire la classe par défaut copiable/assignable, peut-être vous pouvez faire de la non-copiable/cessible par le déclarant, mais pas la mise en œuvre, d'une salle de constructeur de copie et l'opérateur d'affectation.

    Uniquement si aucun des ci-dessus sont faisables devriez-vous mettre en place votre propre constructeur de copie ou de l'opérateur d'affectation.