c++ est-ce que le constructeur de copie implicite copie la variable membre du tableau? [dupliquer]
Doublon Possible:
Comment les membres du tableau C sont-ils gérés dans les fonctions de contrôle de copie?
Je suppose que le constructeur de copie implicite (généré par le compilateur) copierait le pointeur si la variable membre est déclarée comme pointeur.
Je ne suis pas sûr de ce qui arrive à la variable membre du tableau.
Le constructeur de copie implicite copie-t-il correctement le membre du tableau? Comment connaître l'opérateur d'affectation?
Par exemple:
char mCharArray[100];
int mIntArray[100];
Serait le mchararray mIntArray être copié correctement?
4 réponses
Oui et oui est la réponse. Ceci est également vrai des structures en C.
typedef struct {
int a[100];
} S;
S s1;
s1.a[0] = 42;
S s2;
s2 = s1; // array copied
Juste pour le rendre 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 méchant est pour 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 à illustrer le problème.
Considérez une façon de rendre la structure plus "copie-sûre":
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 copy-constructeur rend 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 ou de connexion à l'objet X copié, mais c'est plus lent et potentiellement plus de gaspillage de mémoire.
"constructeur de copie implicite (généré par le compilateur)" - fait une copie superficielle pour toutes les variables.
Oui. Le constructeur de copie et les opérateurs D'affectation sont intégrés en C / C++. Ils font une copie octet par octet (ce qui n'est pas bon pour les tableaux plus grands, car cela provoquera un gonflement du code). Il copie également le pointeur mais ce sera une copie superficielle (si le pointeur pointe vers un emplacement, le pointeur copié pointera également vers le même emplacement).