web-dev-qa-db-fra.com

c ++ le constructeur de copie implicite copie-t-il la variable membre du tableau?

Duplicata possible:
Comment les membres du tableau C sont-ils traités dans les fonctions de contrôle de copie?

Je suppose que le constructeur de copie implicite (généré par le compilateur) copiera le pointeur si la variable membre est déclarée comme pointeur.

Je ne sais pas ce qui arrive à la variable membre du tableau.

Le constructeur de copie implicite copie-t-il correctement le membre du tableau? Que diriez-vous de l'opérateur d'affectation?

Par exemple:

char mCharArray[100];
int mIntArray[100];

Le mCharArray mIntArray serait-il copié correctement?

c++constructorcopyvariable-assignment
29
eugene

Oui et oui est la réponse. Cela est également vrai pour les structures en C.

typedef struct {
    int a[100];
} S;

S s1;
s1.a[0] = 42;
S s2;
s2 = s1;    // array copied
57
Neil Butterworth

Juste pour être aussi clair que possible:

struct X
{
    char data_[100];
};

X a, b;
a.data_[10] = 'x';
b = a;
// here, b.data_[n] == a.data_[n] for 0 <= n < 100, so b.data_[10] == 'x'

MAIS, le cas potentiellement désagréable concerne les pointeurs et les références:

struct X
{
    char* data_[100];
};

X a, b;
a.data_[10] = new char[6]; // a character array on the heap
strcpy(a.data_[10], "hello"); // put some text into it...
b = a;
// here, b.data_[n] == a.data_[n] for 0 <= n < 100
//   so b.data_[10] == a.data_[10] == same character array containing "hello"
// BUT...
b.data_[10][2] = 'L';  // change text to "heLlo" via b.data_[10] pointer...
// here, a.data_[10][2] will be 'L' too, as a.data_[10] and b.data_[10] both point
// to the same underlying heap memory returned by new above...
delete[] a.data_[10];  // ok...
std::cout << b.data_[10];  // NOT ok - this memory's been deallocated!
delete[] b.data_[10];  // NOT ok - this memory's (already) been deallocated!

Espérons que cela aide à illuster le problème.

Considérez une façon de rendre la structure plus "protégée contre la copie":

struct X
{
    X(const X& rhs)
    {
        for (int i = 0; i < 100; ++i)
            if (rhs.data_[i])
            {
               // deep copy of pointed-to text...
               data_[i] = new char[strlen(rhs.data_[i]) + 1];
               strcpy(data_[i], rhs.data_[i]);
            }
            else
               data_[i] = NULL;
    }
    char* data_[100];
};

Ici, le constructeur de copie fait X b = a plus sûr et plus intuitif car il fait sa propre copie de toutes les données de chaîne et n'a plus de dépendance ni de connexion à l'objet X copié, mais cela est plus lent et peut être plus coûteux en mémoire.

8
Tony Delroy

"constructeur de copie implicite (généré par le compilateur)" - effectue une copie superficielle pour toutes les variables.

1
Sujay Ghosh