Directorio de artículos
1. Crear objetos de instancia de clases en diferentes memorias.
En el blog anterior [C ++] Clasificación de constructores ② (Crear objetos de instancia de una clase en diferentes memorias | Crear objetos de instancia en la memoria de pila | Crear objetos con la nueva palabra clave), se analizó la creación de objetos en la memoria de pila y la memoria de montón. Dos situaciones ;
En este blog, continuaremos analizando los dos métodos para llamar a un constructor parametrizado en la memoria de la pila:
- horquillado
- método del signo igual
Las variables miembro de la clase C++ son:
public:
int m_age;
char* m_name;
Posteriormente, esta variable miembro se utiliza como referencia para asignar valores a estas dos variables miembro;
1. Llamar al constructor usando el método de corchetes
Primero, en la clase Estudiante, defina dos constructores con parámetros y luego use el método de corchetes para llamar a los constructores anteriores;
// 有参构造函数
Student(int age, const char* name)
{
// 方法体 省略
cout << "调用有参构造函数" << endl;
}
Uso no recomendado: llame manualmente al constructor parametrizado a través del método Student (18, "Tom"). El código anterior generará un objeto de instancia de Student anónimo y luego asignará el objeto anónimo a la variable Student s2 en la memoria de la pila.
Una vez creado el objeto anónimo, se inicializará inmediatamente;
// 手动调用有参构造函数
// 直接调用构造函数会产生匿名对象, 涉及到该匿名对象的生命周期
Student s2 = Student(18, "Tom");
Uso recomendado: para crear un objeto de instancia de una clase en la memoria de la pila, se recomienda utilizar el siguiente método: utilice paréntesis directamente después del nombre de la variable de la memoria de la pila declarada y pase los parámetros del constructor;
// 使用 括号法 调用有参构造函数
Student s4(1, "J");
Llamar a Student s4(1, "J") para crear un objeto de instancia es equivalente a llamar al constructor parametrizado Student(int age, const char* name) y luego asignar el objeto de instancia a la variable s4;
2. Llame al constructor usando el método del signo igual.
Primero, defina un constructor de un solo parámetro;
// 有参构造函数
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;
}
Utilice el método del signo igual para llamar a un constructor parametrizado con un parámetro,
Asignar la cadena directamente a la variable Student s5 equivale a llamar al constructor parametrizado Student(const char* name) y asignar el objeto de instancia creado a la variable s5.
Esta es una =mejora de C++ para el operador de signo igual;
// 使用 等号法 调用 有一个参数的 有参构造函数
// C++ 对等号进行了功能增强
Student s5 = "K";
2. Ejemplo de código completo
En el siguiente código,
Al declarar la clase Estudiante, definimos:
- Constructor sin parámetros predeterminado
- Constructor paramétrico - 1 parámetro
- Constructor paramétrico - 2 parámetros
- Copiar constructor: un constructor parametrizado con 1 parámetro, el tipo de función es Student(const Student& obj)
Al llamar al constructor para crear un objeto de instancia, use
- Declare directamente la variable Student y llame automáticamente al constructor predeterminado sin argumentos.
- Utilice paréntesis para llamar a un constructor parametrizado de 2 parámetros
- Llamar al constructor de copia
- Utilice el método del signo igual para llamar al constructor parametrizado de 1 parámetro
Ejemplo de código:
#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;
}
Resultados de:
调用无参构造函数
name : name , age : 0
调用有参构造函数
name : Tom , age : 18
调用有参构造函数
name : J , age : 1
调用有参构造函数
name : K , age : 0
调用拷贝构造函数
name : Tom , age : 18
请按任意键继续. . .
