Copier Constructeur

Question

Im essayant de faire la part de la copie d'une « copie en profondeur » avec mon constructeur de copie:

class myClass 
{ 
public: 

    myClass (const char *cPtr, const float fValue) 
    myClass (const myClass& myClassT); 

private: 

    const char* &myAddress; 
    float MyFloater; 

}; 

//myClass.cpp 

myClass::myClass(const char *cPtr, const float fValue) 
{ 
// Initialize both private varaible types 
    const char* &myAddress = cPtr; 
    float myFloater = fValue; 
} 

myClass::myClass(const myClass& classType) 
{ 
// copy what we did ... 
     myAddress = myClass.myAddress; 
     myFloater = myClass.myFloater; 
} 

avec juste que, im obtenir seulement, « doit initialiser whataver varaible dans la base/membre initalizer liste .

Ils sont initalized dans le constructeur Qu'aurais-je besoin de le faire avec l'adresse objet classtype

Answer 1

Plusieurs problèmes:?

1) Pourquoi répétez-vous la déclaration de variable dans le premier constructeur?

2) Pourquoi déclarez-vous myAddress comme référence plutôt que simplement comme pointeur? Une référence doit toujours être initialisée dans la liste d'initialisation du constructeur. C'est probablement la cause de votre message d'erreur. L'initialisation dans le corps du constructeur n'est pas acceptable pour C++.

Dans le second constructeur, vous voulez probablement quelque chose comme:

myClass::myClass(const myClass& classType):myAddresss(classType.myAddress), myFloater(classType.myFloater) 
{ 
} 

La raison doit faire avec la façon dont sont construits les objets. Au moment où le corps du constructeur s'exécute, l'objet est déjà considéré comme ayant été "construit" donc les références devraient déjà être valides, donc votre assignation d'une référence est rejetée par C++.

Et par ailleurs, ce n'est pas vraiment une copie en profondeur ...

Answer 2

const char* &myAddress; 

est une référence, il doit être initialisé dans une liste d'initialisation au cours du constructeur, à savoir

myClass::myClass(const char *& cPtr, const float fValue): myAddress(cPtr) 

Notez que c'est une mauvaise façon de gérer cette situation (bien sûr, en fonction de ce que vous essayez de faire), puisque si le pointeur passé est hors de portée, alors vous êtes foutu.

Une meilleure façon de le faire (encore une fois, en fonction de ce que vous essayez de faire) est juste de copier le pointeur, et lors de votre copie "profonde", réaffecter et copier son contenu. À moins que vous ayez réellement besoin d'une référence au pointeur, bien sûr.

Answer 3

Vous n'initialisez pas les membres dans le constructeur, vous déclarez deux nouvelles variables locales avec les mêmes noms que ceux de la classe. Et les initialiser avec une liste d'initialiseur ressemblerait à ceci:

myClass::myClass(const char *cPtr, const float fValue) 
    : myAdress(cPtr), myFloater(fValue) 
{ 
} 

Answer 4

en plus de ce que les autres ont dit, vous ne faites pas vraiment une « copie profonde » ce que vous faites est mise le pointeur au point même, que n'est pas une copie profonde. Vous devez dupliquer ce que le pointeur indique également (pour être du bon côté).

Answer 5

Essayez d'avoir votre code comme ceci:

class myClass 
{ 
public: 

    myClass (const char *cPtr, const float fValue); 
    myClass (const myClass& myClassT); 

private: 

    const char* &myAddress; 
    float MyFloater; 

}; 

//myClass.cpp 

myClass::myClass(const char *cPtr, const float fValue) : myAddress(cPtr), MyFloater(fValue) 
{ 
} 

myClass::myClass(const myClass& classType) : myAddress(classType.myAddress), MyFloater(classType.MyFloater) 
{ 
// copy what we did ... 
}