目录
对象的初始化和清理：
why?
如何进行初始化和清理呢？
使用构造函数和析构函数编辑
构造函数语法:
析构函数语法:
构造函数的分类：
两种分类方式：
三种调用方法：
括号法（默认构造函数调用）
显示法
隐式转换法
拷贝调用函数的调用时机
1.使用一个已经常见完毕的对象来初始化一个新对象
2.值传递的方式给函数参数传值。
3.以值方式返回局部对象
构造函数调用时机：
深拷贝浅拷贝：
有可能的错误：
错误原因：
解决方案：
深拷贝和浅拷贝案例：
初始化列表
基本初始化列表案例：
灵活定义初始化的数字时的初始化列表案例：
类对象作为类成员
静态成员
静态成员变量：
静态成员变量访问案例：
访问方式：
静态成员函数
静态成员函数创建调用基本示例
why?
结语：
本篇博客讲解c++入门学习④有关对象的初始化以及清理的知识点💪
传送门：
c++入门学习①-CSDN博客
c++入门学习②-CSDN博客
c++入门学习③——封装-CSDN博客
对象的初始化和清理：
why?
为了保证数据安全👉一个对象或者是变量没有初始化，则后面的后果是未知的，同样，没有清理也是可能会造成一系列的安全问题。
如何进行初始化和清理呢？
使用构造函数和析构函数
构造函数语法:
类名(){}
1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次自己不写，程序会自动帮你实现，不过函数里面的代码是空的，要是自己写，程序运行你自己写的构造函数
析构函数语法:
~类名(){}
1.析构函数，没有返回值也不写void
2.函数名称与类名相同,在名称前加上符号
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次自己不写，程序会自动帮你实现，不过函数里面的代码是空的，要是自己写，程序运行你自己写的析构函数
代码：
#include<iostream> #include<string> using namespace std; class person{ public: //创造构造函数 person() { cout << "构造函数" << endl; } ~person() { cout << "析构函数调用" << endl; } }; void test1() { person a; }//局部变量，在栈区上创建，test执行完毕后，释放对象，会自动实现析构函数，不过是空的 //当自己创建了一个，那么就执行自己创建的析构函数 int main() { test1(); system("pause"); return 0; }
构造函数的分类：
两种分类方式：
按照参数分类：有参数和无参数（默认情况下为无参）
按照类型分类：普通和拷贝
拷贝：copy、复制，
例如：person（const person &a){name=a.name;};把其他的属性拷贝到这个上面
拷贝方式创建，注意括号里写要copy的对象，并加上const，以引用的方式写入。
三种构造函数的具体表示：
#include<iostream> #include<string> using namespace std; class person{ public: //创造构造函数 person() { cout << "默认构造函数" << endl; } person(int age) { cout << "有参构造函数" << endl; Age = age; } person(const person& p) { cout << "拷贝构造函数" << endl; Age = p.Age; } ~person() { cout << "析构函数调用" << endl; } int Age; };
引用：c++引用-CSDN博客
三种调用方法：
括号法（默认构造函数调用）
person p1;调用无参构造函数，也是默认构造函数调用；
person p2(12);调用有参构造函数
person p3(p2);调用拷贝构造函数
注意事项：调用默认构造函数的时候不要加（），因为编译器会认为这个是一个函数声明，不会认为在创建对象
显示法
person p1;默认构造
person p2=person(12);有参构造
person p3=person(p2);拷贝构造
单独拿出来person(12),称为匿名对象，当前执行结束后，系统会立即回收掉匿名对象，马上析构掉
不单独看这个，匿名对象就有名字了，左边的就是它的名字
注意：不要利用拷贝构造函数初始化匿名对象。编译器会认为person(p3)==person p3;认为这是一个对象声明
隐式转换法
person p4=10;相当于写了person p4=person(10)有参构造
person p5=p4;拷贝构造
括号法最简单，这里推荐使用这个
拷贝调用函数的调用时机
1.使用一个已经常见完毕的对象来初始化一个新对象
#include<iostream>
using namespace std;
class person{
public:
//创造构造函数
person() {
cout << "默认构造函数" << endl;
}
person(int age) {
Age = age;
cout << "有参构造函数" << endl;
}
person(const person & a) {
Age = a.Age;
cout << "拷贝构造函数" << endl;
}
~person() {
cout << "析构函数调用" << endl;
}
int Age;
};
void test1() {
person a;//局部变量，在栈区上创建，test执行完毕后，释放对象
}
//使用一个已经创建完毕的对象来初始化一个新的对象
void test2() {
person p(20);//调用有参构造函数
person p1(p);//调用拷贝构造函数
}
int main()
{
//test1();
test2();
system("pause");
return 0;
}输出结果：
2.值传递的方式给函数参数传值。
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
class person{
public:
//创造构造函数
person() {
cout << "默认构造函数" << endl;
}
person(int age) {
Age = age;
cout << "有参构造函数" << endl;
}
person(const person & a) {
Age = a.Age;
cout << "拷贝构造函数" << endl;
}
~person() {
cout << "析构函数调用" << endl;
}
int Age;
};
//值传递的方式给函数参数传值
void test(person p)
{
}
void test3() {
person p;//调用默认构造函数
test(p);//调用拷贝构造函数，因为这里是以值传入，相当于拷贝一个副本传进去
}
int main()
{
//test1();
//test2();
test3();
return 0;
}
3.以值方式返回局部对象
示例：
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
class person{
public:
//创造构造函数
person() {
cout << "默认构造函数" << endl;
}
person(int age) {
Age = age;
cout << "有参构造函数" << endl;
}
person(const person & a) {
Age = a.Age;
cout << "拷贝构造函数" << endl;
}
~person() {
cout << "析构函数调用" << endl;
}
int Age;
};
//以值返回局部对象
person test0() {
person p;//局部对象在完成函数之后会被自动释放掉，但是现在以值方式返回，则在返回的时候会自动给创建一个新的对象
cout << "p地址" << (int*) & p << endl;
return p;//返回的是p拷贝的一个新的对象
}
void test4() {
person a=test0();//这里的函数a没有调用析构函数和构造函数
cout << "a地址" << (int*)&a << endl;
}
int main()
{
//test1();
//test2();
//test3();
test4();
system("pause");
return 0;
}构造函数调用时机：
默认情况添加的函数：
⭐注意：拷贝构造函数默认情况下只写值传递语句，不会出现输出语句
构造函数调用规则如下:
若用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造函数，当仅定义有参构造函数时不要进行默认无参构造，会发生错误显示没有默认无参构造函数。
若用户定义拷贝构造函数，c++不会再次提供其他构造函数
只定义拷贝构造函数时如果使用其他的构造函数，则会发生错误
深拷贝浅拷贝：
一般浅拷贝是逐个字节依次复制过去，而默认情况下系统创建拷贝构造函数是浅拷贝
有可能的错误：
一般使用不会出错，但是如果数据是程序员开发在堆区，就会发生释放重复的错误
错误原因：
因为浅拷贝使两个对象里的属性指向同一块空间，当释放一个对象中的属性之后，再去释放另一个也在堆区的数据，由于她们指向相同，所指向的空间已经被释放，但是系统不知道因此会发生错误
解决方案：
改进方法就是进行深拷贝，程序员自己创建一个函数来达到深拷贝的效果，深拷贝是在拷贝构造函数内进行自己再开辟一片空间，只复制要拷贝对象属性的内容而非空间地址。
深拷贝和浅拷贝案例：
#include<iostream>
using namespace std;
class person{
public:
//创造构造函数
person() {
cout << "默认构造函数" << endl;
}
person(int age,int height) {
Age = age;
high = new int(height);
cout << "有参构造函数" << endl;
}
person(const person & a) {
Age = a.Age;
cout << "person的拷贝构造函数" << endl;
high=new int(*a.high);
}
~person() {
//析构代码，将堆区开辟数据做释放操作
if (high != NULL) {
delete high;
high = NULL;
}//加上这个代码后运行，发现程序崩溃了？
cout << "析构函数调用" << endl;
}
int Age;
int* high;//身高，使用指针，把这个参数存放在堆区
//堆区的数据，由程序员手动开辟，也由程序员手动释放，销毁前释放，在析构之前释放
};
void test1() {
person p1(18,160);
cout << "p1年龄：" << p1.Age<<"p1身高为："<<*p1.high << endl;
person p2(p1);//编译器创建了一个拷贝函数，进行了一个浅拷贝的操作，简单的赋值操作，逐字节拷贝
cout << "p2年龄：" << p2.Age<< "p2身高为：" <<*p2.high << endl;
//栈区先进后出，所以p2先被释放，p2先执行析构函数，p2释放过了指针所指的内存，则再次用p1释放时发生错误
//解决：浅拷贝用深拷贝改进，不是逐个字节拷贝了，是重新开辟一个空间，两个空间就不会存在重复释放了
//自己写拷贝构造函数
}
int main()
{
test1();
system("pause");
return 0;
}
初始化列表
简介：
初始化类中属性：1创建构造函数2.初始化列表
构造函数（）：属性1（值1），属性2（值2）
基本初始化列表案例：
#include<iostream>
using namespace std;
//初始化列表
//初始化类中属性：1创建构造函数2.初始化列表
// 构造函数（）：属性1（值1），属性2（值2）
class person{
public:
//初始化列表给类属性赋初值；
person() :Age(10),b(20)
{
}
int Age;
int b;
};
void test1() {
person p1;
cout << p1.Age <<"\t" << p1.b << endl;
}
int main()
{
test1();
system("pause");
return 0;
}
灵活定义初始化的数字时的初始化列表案例：
#include<iostream>
using namespace std;
//初始化列表
//初始化类中属性：1创建构造函数2.初始化列表
// 构造函数（）：属性1（值1），属性2（值2）
class person{
public:
//初始化列表给类属性赋初值；
person(int a,int n) :Age(a),b(n)//注意这个冒号的位置，别写错了
{
}
int Age;
int b;
};
void test1() {
person p1(12,22);//12先传给了p1中的int a，然后传入到Age里的a,这样Age就被这个数字赋值了，被初始化了。
cout << p1.Age <<"\t" << p1.b << endl;
}
int main()
{
test1();
system("pause");
return 0;
}
类对象作为类成员
类定义的对象称为另一个类里的成员，则称为类成员
构造顺序和析构顺序相反
构造时，先构造类成员的类，再构造类成员所在的类
而析构顺序则正相反。
#include<iostream>
#include<string>
using namespace std;
//类对象成为另一个对象的成员，称为类成员
//先有的什么？👉先构造其他的类的对象，再构造这个类
//那么析构的顺序呢？和构造的顺序是相反的。
class A {
public:
// 可以用Phone a_phone=pname👉隐式转换法来初始化变量
A(string Name, string pname):name(Name),a_phone(pname)
{
cout << "A的构造函数" << endl;
}
//姓名
string name;
//手机
Phone a_phone;//类成员
};
//手机类
class Phone{
public:
Phone(string pname) {//Phone 的构造函数
Pname = pname;
cout << "Phone的构造函数" << endl;
}
//手机品牌名
string Pname;
};
void test1() {
A p("黑菜钟","华为");
cout << "名字:"<<p.name<< endl;
cout <<"手机型号:"<< p.a_phone << endl;
}
int main()
{
test1();
system("pause");
return 0;
}静态成员
定义：静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
分为：静态成员变量和静态成员函数
静态成员变量要求：所有对象共享同一份数据，编译阶段分配内存，类内声明，类外初始化
静态成员函数要求：
静态成员变量：
静态成员变量示例：
当静态成员变量像平常一样定义类对象并且输出所对应的值的时候，程序会怎么样？
结果：发生错误，无法解析的外部命令👉这是因为静态成员变量要类外进行初始化操作，这个程序显然没做
如何在类外初始化呢？👉int person::m = 100;（这里的person是类名，m是类内静态变量）
静态成员变量访问案例：
⭐静态成员变量不属于某个对象，所有对象共享同一份
访问方式：
1.通过对象访问
person p;
cout<<p.m_A<<endl;
2.通过类名访问
cout << person::m_A << endl;
#include<iostream>
#include<string>
using namespace std;
//静态成员变量
//所有对象共享同一份数据
// 编译阶段分配内存
// 类内声明，类外初始化
class person {
public:
static int m_A;
};
int person::m_A = 10;
void test1() {
person p;
cout << p.m_A << endl;//10
person p2;
p2.m_A = 20;
cout << p.m_A << endl;//结果为20，因为所有对象共享数据，一改全改
//静态成员变量不属于某个对象，所有对象共享同一份
}
void test2() {
//访问方式1.通过对象访问
person p;
cout<<p.m_A<<endl;//20
//访问方式2.通过类名访问
cout << person::m_A << endl;//用::来借助访问类对象
}
int main()
{
test1();
test2();
system("pause");
return 0;
}注意：静态成员变量只能在公共权限内定义，在私有权限内定义不出错，但是不能共享数据。类外访问不到私有静态变量。
静态成员函数
特点：所有对象共享同一个函数，静态成员函数只能访问静态成员变量
静态成员函数创建调用基本示例
#include<iostream>
#include<string>
using namespace std;
//静态成员函数
//所有对象共享同一个函数
// 静态成员函数只能访问静态成员变量
class person {
public:
static void func() {
cout << "static void func调用" << endl;
}
};
void test1()
{
//访问方式和静态成员变量的访问方式相同
//1.通过对象
person p;
p.func();
//2.通过类名
person::func();
}
int main()
{
test1();
system("pause");
return 0;
}
如果静态成员函数访问非静态成员变量会出现👉这样的结果
why?
数据属于特定的，而函数体无法区分是哪个对象的，会出错
而静态成员变量是共享的，所有类的对象都用一份，函数体不需要知道这是哪个类对象对应的
⭐注意： 类外还是不可以访问私有的静态成员函数
结语：
希望这篇有关c++对象初始化和清理的博客对大家有所帮助，欢迎大佬们留言o(*￣▽￣*)ブ
一起学习进步！！！
