c Résumé des points clés de l'examen 3 - Constructeur

Constructeur : La fonction portant le même nom que la classe est le constructeur, sans déclaration de type de valeur de retour.

Classification des constructeurs : constructeur sans paramètre, constructeur paramétré, constructeur d'affectation (copie)

Test() //无参构造函数定义
Test(inta, int b) //有参构造函数定义
Test(const Test &obj) //拷贝构造函数定义

Les trois types de constructeurs suivants sont abordés séparément

1. Constructeur sans paramètre

Méthode d'appel : Test t1, t2; //C'est facile à comprendre

2 Il existe trois types de constructeur paramétré

Méthode d'appel :

class Test5
{ public: 
Test5(inta); 
Test5(int a, int b);
}
void main（）
{ Test5 t1(10); //c++编译器默认调用有参构造函数 括号法
Test5 t2 = (20, 10); //c++编译器默认调用有参构造函数 等号法
Test5 t3 = Test5(30); //程序员手工调用构造函数 产生了一个对象 直接调用构造构造函数法
}

3. Constructeur de copie

Pourquoi il existe un constructeur de copie - pour résoudre le problème de copie des objets de classe

Pour les types ordinaires Pour les objets, copie entre C'est très simple, par exemple :

int a=88;
int b=a;

Mais les objets de classe sont différents des objets ordinaires. La structure interne des objets de classe est généralement plus complexe et il existe diverses variables membres. Regardons un exemple simple de copie d'objet de classe.

#include <iostream>
using namespace std;
class CExample {
private:
　int a;
public:
　CExample(int b)
　{ a=b;}
　void Show ()
　{
cout<<a<<endl;
}
};
int main()
{
　CExample A(100);
　CExample B=A;
　B.Show ();
　return 0;
}

Exécutez le programme et l'écran affiche 100. Il ressort des résultats d'exécution du code ci-dessus que le système alloue de la mémoire pour l'objet B et termine le processus de copie avec l'objet A. En ce qui concerne les objets de classe, l'ensemble du processus de copie des objets de classe du même type est effectué via le constructeur de copie. L'exemple suivant illustre le processus de travail du constructeur de copie.

#include <iostream>
using namespace std;
class CExample {
private:
int a;
public:
CExample(int b)
{ a=b;}
CExample(const CExample& C)
{
a=C.a;
}
void Show ()
{
cout<<a<<endl;
}
};
int main()
{
CExample A(100);
CExample B=A;
B.Show ();
return 0;
} 
CExample(const CExample&
C)

est notre constructeur de copie personnalisé. On voit que le constructeur de copie est un constructeur spécial. Le nom de la fonction doit être cohérent avec le nom de la classe. Son seul paramètre est une variable de référence de ce type. Le paramètre est de type const et est immuable. Par exemple : la forme du constructeur de copie de la classe X est X(X& x).

Lorsqu'un objet de type classe personnalisé initialisé est utilisé pour initialiser un autre objet nouvellement construit, le constructeur de copie sera automatiquement appelé. En d’autres termes, lorsqu’un objet de la classe doit être copié, le constructeur de copie sera appelé. Le constructeur de copie sera appelé dans les situations suivantes :

Un objet est passé dans le corps de la fonction par valeur

Un objet est renvoyé par la fonction par valeur

Un objet doit être initialisé via un autre objet.

Si un constructeur de copie n'est pas explicitement déclaré dans la classe, le compilateur générera automatiquement un constructeur de copie par défaut, qui complète la copie de bits entre les objets. La copie binaire est également appelée copie superficielle, ce qui sera expliqué plus tard.

Le constructeur de copie personnalisé est un bon style de programmation, qui peut empêcher le compilateur de former un constructeur de copie par défaut et améliorer l'efficacité du code source.

Copie superficielle et copie profonde

Dans certains cas, les variables membres d'une classe doivent allouer dynamiquement de la mémoire tas. Si une copie binaire est effectuée, la valeur de l'objet est complètement copiée dans un autre. objet. Objet, tel que A=B. À ce stade, si un pointeur de variable membre dans B a alloué de la mémoire, alors la variable membre dans A pointe également vers la même mémoire. Cela crée un problème : lorsque B libère la mémoire (comme une destruction), le pointeur dans A devient un pointeur sauvage et une erreur d'exécution se produit.

La copie profonde et la copie superficielle peuvent être simplement comprises comme : si une classe possède des ressources, lorsque l'objet de cette classe est copié, les ressources sont réaffectées. Ce processus est au contraire une copie profonde. pas de réaffectation des ressources. C'est une copie superficielle. Voici un exemple de copie approfondie.

#include <iostream>
using namespace std;
class CA
{
　public:
　　CA(int b,char* cstr)
　　{
　　　a=b;
　　　str=new char[b];
　　　strcpy(str,cstr);
　　}
　　CA(const CA& C)
　　{
　　　a=C.a;
　　　str=new char[a]; //深拷贝
　　　if(str!=0)
　　　　strcpy(str,C.str);
　　}
　　void Show()
　　{
　　　cout<<str<<endl;
　　}
　　~CA()
　　{
　　　delete str;
　　}
　private:
　　int a;
　　char *str;
};
int main()
{
　CA A(10,"Hello!");
　CA B=A;
　B.Show();
　return 0;
}

La définition de la copie profonde et de la copie superficielle peut être simplement comprise comme : si une classe possède des ressources (tas ou autres ressources système), lorsque l'objet de cette classe est copié , ce processus peut être appelé une copie complète. Sinon, si l'objet a des ressources, mais que les ressources ne sont pas copiées pendant le processus de copie, il est considéré comme une copie superficielle.

Après une copie superficielle des ressources, lorsque les ressources sont libérées, la propriété des ressources ne sera pas claire, ce qui entraînera des erreurs d'exécution du programme.

Test (Test &c_t) est un constructeur de copie personnalisé. Le nom du constructeur de copie doit être cohérent avec le nom de la classe. Le paramètre formel de la fonction est une variable de référence de ce type et doit être une référence.

Lorsque vous utilisez un objet de type classe personnalisé déjà initialisé pour initialiser un autre objet nouvellement construit, le constructeur de copie sera automatiquement appelé. Si vous n'avez pas de constructeur de copie personnalisé, le système fournira un constructeur de copie par défaut à compléter. ce processus. L'instruction de copie principale du code ci-dessus est complétée via l'instruction p1=c_t.p1 dans le constructeur de copie Test (Test &c_t).

Ce qui précède est le troisième résumé des points de révision c - le contenu du constructeur. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !