Tableau dynamique... constructeur de copie, destructeur, d'une surcharge de l'opérateur d'assignation de

Je suis d'étudier pour mon examen de mi-session. Il va y avoir une question à propos de la configuration d'un tableau dynamiquement, et peut-être faire une copie constructeur, un destructeur et la surcharge de l'opérateur d'affectation. Pouvez vous s'il vous plaît vérifier si je suis correct. Aussi je ne comprends pas ce que la surcharge de l'opérateur d'affectation des moyens. Pouvez-vous m'aider avec ça?

class A
{
int* myArray;   //basically I created a pointer called myArray, 
A()             //are my copy constructors correct? A(), and A(int size)?
{
    myArray = 0;
}
A(int size)
{
    myArray = new int[size];
}
~A()             //I think my destructor is correct
{
    delete [] myArray;
}

Pouvez-vous vérifier mon code s'il vous plaît? Aussi comment puis-je la surcharge de l'opérateur d'assignation?

Merci d'avance.

aussi disons que le constructeur prend un int, un float, ou aucun paramètre. Dans chaque cas, les éléments sont initialisés à des valeurs différentes. Est-il possible d'avoir juste un constructeur? Ou dois-je besoin de trois différents constructeurs?

OriginalL'auteur user69699 | 2009-02-24

  1. 6

    Le constructeur de copie est utilisé pour la création de l'objet en fonction d'une autre instance du même type. Vous n'avez pas. Vous pouvez le définir à l'aide de code comme ceci:

    A(const A &other)
{
   myArray = new int[other._size];
   _size = other._size;
   memcpy(myArray, other.myArray, sizeof(int) * _size);
}

    Vous devriez changer votre classe, donc il va stocker _size de tableau, vous devez également modifier la visibilité de votre constructeur et destructeur pour le public.

    La surcharge opérateur d'affectation devrait ressembler à ceci:

    const A &operator=(const A &other)
{
   if(this == &other) return *this; //handling of self assignment, thanks for your advice, arul.
   delete[] myArray; //freeing previously used memory
   myArray = new int[other._size];
   _size = other._size;
   memcpy(myArray, other.myArray, sizeof(int) * _size);
   return *this;
}

    Vous pouvez également ajouter une vérification de l'égalité de la taille des matrices à cet opérateur d'affectation, de sorte que vous pourrez réutiliser votre tableau dynamique inutile sans les réaffectations de mémoire.

    L'opérateur d'affectation doit également gérer l'auto-attribution.
    En général, c'est une bonne idée, pour utiliser le copier-and-swap idiome dans l'affectation des opérateurs - en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Copy-and-swap

    OriginalL'auteur okutane

  2. 7

    Vous avez correctement défini 2 constructeurs surchargés et un destructeur.

    Cependant, vous n'avez pas défini un explicite constructeur de copie correctement.

    Normalement le compilateur va générer pour vous, et cela est appelé un implicite constructeur de copie.

    Le problème avec l'auto-générés implicite constructeur de copie dans votre cas particulier, c'est qu'il va effectuer une copie de myArray, où il partage la même valeur de pointeur, mais n'a pas affecté sa propre section de la mémoire pour myArray.

    Cela signifie que si vous supprimez myArray dans l'objet d'origine, il aura une incidence sur la copie qui n'est probablement pas ce que vous voulez.

    Définir explicitement un constructeur de copie, comme ce sera vous aider:

    A(const A& copy)
  : _size(copy.size), myArray(new int[copy.size]) 
{
    //#include <algorithm> for std::copy
    std::copy(copy.data, copy.data + copy.size, data);
}

    (Source: Copié à partir de Wikipédia)

    Si vous définissez le constructeur de copie de ce genre, vous ne devriez pas avoir besoin de la surcharge de l'opérateur d'affectation. Si vous créez un nouvel objet, et de l'attribuer au premier objet que vous avez créé, vous aurez réussi à créer une copie indépendante de l'objet premier.

    Edit: De cet article:

    L'opérateur d'assignation de copie diffère
    à partir du constructeur de copie en ce qu'il
    doit nettoyer les données membres de la
    affectation de la cible (et correctement
    gérer l'auto-attribution) alors que le
    constructeur de copie attribue des valeurs à
    les données non initialisées membres.

    OriginalL'auteur LeopardSkinPillBoxHat

  3. 4

    lorsque vous traitez avec une copie d'objet et de l'allocation dynamique de la mémoire, c'est une bonne idée d'utiliser un swap fonction d'assistance

    A(const A& other)
    : myArray(0)
    , _size(0)
{
   if(this != &other) {
      A my_tmp_a(other._size);
      std::copy(&other[0], &other[other._size], &my_tmp_a[0]);
      swap(my_tmp_a);
   }
}

const A& operator=(const A& other)
{
   if(this == &other) return *this;
   A my_tmp_a(other._size);
   std::copy(&other[0], &other[other._size], &my_tmp_a[0]); 
   swap(my_tmp_a);       
   return *this;
}

void swap(const A& other) {
   int* my_tmp_array = this.myArray;
   this.myArray = other.myArray;
   other.myArray = my_tmp_array;
   int my_tmp_size = this._size;
   this._size = other._size;
   other._size = my_tmp_size;
}
    +1 pour l'utilisation de la copie et de swap d'un opérateur d'affectation.
    Non besoin de ralentir l'exécution d'un test ce sera inutile de disponibilité de 99,999% du temps. La copie-et-swap idiome est plus que suffisant.

    OriginalL'auteur thrantir

  4. 1

    Veuillez assurez-vous de définir trois fonctions lorsque vous voulez définir un d'entre eux. Son appelé "tout ou rien" de la règle
    Ils sont les suivants:
    1) le constructeur de copie.
    2) l'opérateur d'affectation.
    3) destructeur.

    OriginalL'auteur

  5. 0

    Réponse partielle: la surcharge d'une fonction consiste en la création de différentes versions de cette fonction qui accepte différents nombres et les types des arguments. Si la surcharge de l'opérateur d'affectation serait la création de plusieurs fonctions pour l'opérateur d'affectation qui vous permettent d'assigner des objets de types différents pour une variable de type A.

    OriginalL'auteur David Z