3.21 黑马提高

构造函数调用规则

默认情况下，C++编译器至少给类添加3个函数
1、默认构造函数（无参，函数体 为空）；

2、默认析构函数（无参，函数体 为空）；

3、默认拷贝构造函数，对属性进行值拷贝。

1、如果用户定义有参构造函数，C++不再提供默认无参构造函数，但会提供默认拷贝构造函数；

2、如果用户定义拷贝构造函数，C++不会再提供其他构造函数。

拷贝构造函数的使用规则

include

using namespace std;

class to
{
public:
to()
{
printf("构造\n");
}
~to()
{
printf("析构\n");
}
to(const to& q)
{
printf("拷贝构造\n");
}

};

void func(to a)
{

}

void test2()
{
//已有的对象去初始化另一个对象
to we;
to t1(we);

}

to func2()
{
//局部对象
to z;
return z;

}
int main()
{
func2();

}

2.多个对象的析构 和构造

include

using namespace std;

class to1
{
public:
to1(int a)
{
printf("构造1\n:%d",a);
}
~to1()
{
printf("析构1\n");
}
to1(const to1& q)
{
printf("拷贝构造1\n");
}

};

class to2
{
public:
to2(int c)
{
printf("构造2\n");
}
~to2()
{
printf("析构2\n");
}
to2(const to2& q)
{
printf("拷贝构造2\n");
}

};

class to3
{

public:
to3():eq(3), e(4)
{
printf("拷贝构造3\n");

}
	
to2 e;
to1 eq;

};

int main()
{
to3 eqq;

}

3.深浅拷贝
浅拷贝

include

using namespace std;

class to
{
public:
int c=0;
to(int a)
{
c = a;
printf("构造1\n:%d",c);
}
~to()
{
printf("析构1\n");
}

};

int main()
{
to eqq(3);
to eqq2(eqq);

}

默认拷贝问题

class to
{
public:
int c=0;
char* pname;
to(const char* a,int age)
{
c = age;
pname = (char*)malloc(strlen(a) + 1);
strcpy(pname, a);
printf("构造:%d %s\n",c, pname);
}
~to()
{
if (pname != NULL)
{
free(pname);
pname = NULL;
}
printf("析构\n");
}

};

int main()
{
to eqq("小草",12);
to eqq2(eqq);

}

int c=EQQ.C;
NAME=EQQ.NAME;
name不为空 free无法二次释放

深拷贝

include

using namespace std;

class to
{
public:
int c=0;
char* pname;
char* zz;
to(const char* a,int age)
{
c = age;
pname = (char*)malloc(strlen(a) + 1);
strcpy(pname, a);
printf("构造:%d %s\n",c, pname);
}
~to()
{
if (pname != NULL)
{
free(pname);
pname = NULL;
}
printf("析构\n");
}

to(const class to& a)
{
	pname = (char*)malloc(strlen(a.pname) + 1);
	strcpy(pname, a.pname);
	c = a.c;
}

};

int main()
{
to eqq("小草",12);//
/*
int c=EQQ.C;
NAME=EQQ.NAME;

*/
to eqq2(eqq);
printf("%s哈哈\n", eqq2.pname);

}

explicit
只能放在构造函数前,构造函数只有一个参数或者其他参数有默认值时

include

using namespace std;

class to
{
public:
explicit to(int n)
{
}

};
int main()
{
to z = 10;//to z(10) 编译器默认优化

}

静态成员
1.静态成员变量的生命周期是整个程序，作用域在类内
2.静态成员变量在类内声明，类外初始化
3.属于类，所有对象共享
4.类 访问 对象访问都可以
class to
{
public:
static int mm;
to(int n)
{

}

};
int to::mm = 100;
int main()
{
printf("%d", to::mm);

}
静态函数只能 访问静态变量
也是每个成员共有的可以类访问

include

using namespace std;

class to
{
public:
static int mm;
int age = 12;
to(int n)
{

}
static void test()
{
	printf("%d", mm);//erro
	
}

};
int to::mm = 100;
int main()
{
to::test();

}