Si no hay un constructor de copia, el sistema proporcionará automáticamente (copia superficial) un constructor de copia. En este caso, si se crea un nuevo objeto, los datos de la clase se asignarán al nuevo objeto. Pero si hay un puntero en la clase, se le asignará el puntero, pero esto causará confusión. Entonces esto lleva a la auto escritura del constructor de la copia.
#include<iostream>
using namespace std;
class student
{
int a;
public:
student()
{
a=100;
}
void getA()
{
cout<<a<<endl;
}
};
int main()
{
student stu1;
student stu2(stu1);//stu2=stu1;//
st2.getA();
system("pause");
return 0;
}Los datos anteriores son una copia superficial, solo una copia entre datos y datos
Estructura de copia: nombre de clase (nombre de clase constante y nombre de referencia);
#include<iostream>
using namespace std;
class stu
{
char *p;
public:
student(char *str)
{
p=new char[strlen(str)+1];
strcpy(p.str);
}
void getA()
{
cout<<p<<endl;
}
student(const student&stu)
{
p=new char[strlen(stu.p)+1];
strcpy(p,stu.p);
}
};
void test(student stu)
{
}
student text(student stu)
{
return stu;
}
int main()
{
student stu1("39-lijimin");
//text(stu1).getA();//第三种情况，用完就直接释放了，调用析构函数
//test(stu1);//拷贝构造函数的第二种调用情况
//stu2=stu1;//创造新的类型，用旧的类型赋值的时候，是要求调用拷贝构造的
}Copiar la situación de la llamada al constructor:
1. Cuando se usa un objeto de clase para inicializar otro objeto de la clase,
2. Si el parámetro formal de la función es un objeto de la clase, cuando el parámetro real se pasa cuando se llama a la función, la construcción de la copia se llama
3. Si El valor de retorno de una función es un objeto de clase, cuando regresa la llamada a la función.
