Annuaire d'articles
1. Créer des objets d'instance de classes dans différentes mémoires
Dans le blog précédent [C++] Constructor Classification ② (Création d'objets d'instance d'une classe dans différentes mémoires | Création d'objets d'instance dans la mémoire de pile | Création d'objets avec le nouveau mot-clé), la création d'objets dans la mémoire de pile et la mémoire de tas a été analysée. Deux situations ;
Dans ce blog, nous continuerons à analyser les deux méthodes d'appel d'un constructeur paramétré dans la mémoire de la pile :
- bracketing
- méthode du signe égal
Les variables membres de la classe C++ sont :
public:
int m_age;
char* m_name;
Ensuite, cette variable membre est utilisée comme référence pour attribuer des valeurs à ces deux variables membres ;
1. Appel du constructeur à l'aide de la méthode bracket
Tout d'abord, dans la classe Student, définissez deux constructeurs avec des paramètres, puis utilisez la méthode bracket pour appeler les constructeurs ci-dessus ;
// 有参构造函数
Student(int age, const char* name)
{
// 方法体 省略
cout << "调用有参构造函数" << endl;
}
Utilisation non recommandée : Appelez manuellement le constructeur paramétré via la méthode Student(18, "Tom"). Le code ci-dessus générera un objet d'instance Student anonyme, puis affectera l'objet anonyme à la variable Student s2 dans la mémoire de la pile. ;
Une fois l’objet anonyme créé, il sera immédiatement initialisé ;
// 手动调用有参构造函数
// 直接调用构造函数会产生匿名对象, 涉及到该匿名对象的生命周期
Student s2 = Student(18, "Tom");
Utilisation recommandée : Pour créer un objet instance d'une classe dans la mémoire de pile, il est recommandé d'utiliser la méthode suivante : utilisez des parenthèses directement après le nom de la variable de mémoire de pile déclarée et transmettez les paramètres du constructeur ;
// 使用 括号法 调用有参构造函数
Student s4(1, "J");
Appeler Student s4(1, "J") pour créer un objet instance équivaut à appeler le constructeur paramétré Student(int age, const char* name), puis à affecter l'objet instance à la variable s4 ;
2. Appelez le constructeur en utilisant la méthode du signe égal
Tout d’abord, définissez un constructeur à paramètre unique ;
// 有参构造函数
Student(const char* name)
{
// 为 m_name 成员分配内存
m_name = (char*)malloc(100);
// 为 m_name 成员设置字符串值
if (m_name != NULL)
{
strcpy_s(m_name, sizeof(name), name);
}
// 为 m_age 成员设置初始值
m_age = 0;
cout << "调用有参构造函数" << endl;
}
Utilisez la méthode du signe égal pour appeler un constructeur paramétré avec un paramètre,
Attribuer la chaîne directement à la variable Student s5 équivaut à appeler le constructeur paramétré Student(const char* name) et à attribuer l'objet d'instance créé à la variable s5.
Il s'agit d'une amélioration C++ =de l'opérateur de signe égal ;
// 使用 等号法 调用 有一个参数的 有参构造函数
// C++ 对等号进行了功能增强
Student s5 = "K";
2. Exemple de code complet
Dans le code ci-dessous,
Lors de la déclaration de la classe Student, nous définissons :
- Constructeur sans paramètre par défaut
- Constructeur paramétrique - 1 paramètre
- Constructeur paramétrique - 2 paramètres
- Constructeur de copie - un constructeur paramétré avec 1 paramètre, le type de fonction est Student(const Student& obj)
Lorsque vous appelez le constructeur pour créer un objet instance, utilisez
- Déclarez directement la variable Student et appelez automatiquement le constructeur sans argument par défaut.
- Utilisez des parenthèses pour appeler un constructeur paramétré à 2 paramètres
- Appeler le constructeur de copie
- Utilisez la méthode du signe égal pour appeler le constructeur paramétré à 1 paramètre
Exemple de code :
#include "iostream"
using namespace std;
class Student
{
public:
// 无参构造函数
Student()
{
// 为 m_name 成员分配内存
m_name = (char*)malloc(100);
// 为 m_name 成员设置字符串值
if (m_name != NULL)
{
strcpy_s(m_name, 5, "name");
}
// 为 m_age 成员设置初始值
m_age = 0;
cout << "调用无参构造函数" << endl;
}
// 有参构造函数
Student(const char* name)
{
// 为 m_name 成员分配内存
m_name = (char*)malloc(100);
// 为 m_name 成员设置字符串值
if (m_name != NULL)
{
strcpy_s(m_name, sizeof(name), name);
}
// 为 m_age 成员设置初始值
m_age = 0;
cout << "调用有参构造函数" << endl;
}
// 有参构造函数
Student(int age, const char* name)
{
// 为 m_name 成员分配内存
m_name = (char*)malloc(100);
// 为 m_name 成员设置字符串值
if (m_name != NULL)
{
strcpy_s(m_name, sizeof(name), name);
}
// 为 m_age 成员设置初始值
m_age = age;
cout << "调用有参构造函数" << endl;
}
// 拷贝构造函数
Student(const Student& obj)
{
// 为 m_name 成员分配内存
m_name = (char*)malloc(100);
// 为 m_name 成员设置字符串值
if (m_name != NULL)
{
strcpy_s(m_name, sizeof(obj.m_name), obj.m_name);
}
// 为 m_age 成员设置初始值
m_age = obj.m_age;
cout << "调用拷贝构造函数" << endl;
}
~Student()
{
// 销毁 name 指向的堆内存空间
if (m_name != NULL)
{
free(m_name);
}
cout << "调用析构函数" << endl;
}
public:
int m_age;
char* m_name;
};
int main()
{
// 声明 Student 类型实例对象
// 调用无参构造函数
Student s1;
// 打印 Student s1 实例对象值
cout << "name : " << s1.m_name << " , age : " << s1.m_age << endl;
// 手动调用有参构造函数
// 直接调用构造函数会产生匿名对象, 涉及到该匿名对象的生命周期
Student s2 = Student(18, "Tom");
// 打印 Student s1 实例对象值
cout << "name : " << s2.m_name << " , age : " << s2.m_age << endl;
// 使用 括号法 调用有参构造函数
Student s4(1, "J");
// 打印 Student s4 实例对象值
cout << "name : " << s4.m_name << " , age : " << s4.m_age << endl;
// 使用 等号法 调用 有一个参数的 有参构造函数
// C++ 对等号进行了功能增强
Student s5 = "K";
// 打印 Student s4 实例对象值
cout << "name : " << s5.m_name << " , age : " << s5.m_age << endl;
// 调用拷贝构造函数
Student s3 = Student(s2);
// 打印 Student s3 实例对象值
cout << "name : " << s3.m_name << " , age : " << s3.m_age << endl;
// 控制台暂停 , 按任意键继续向后执行
system("pause");
return 0;
}
Résultats du :
调用无参构造函数
name : name , age : 0
调用有参构造函数
name : Tom , age : 18
调用有参构造函数
name : J , age : 1
调用有参构造函数
name : K , age : 0
调用拷贝构造函数
name : Tom , age : 18
请按任意键继续. . .
