4.2 对象的初始化和清理
4.2.1 构造函数和析构函数
对象的初始化和清理也是两个非常重要的安全问题
- 一个对象或者变量没有初始化状态,对其使用后果是未知
- 同样的使用完一个对象或变量,没有及时清理,也会造成一定的安全问题
C++利用了构造函数和析构函数解决上述问题,这两个函数将会被编译器自动调用,完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制我们做的事情,因此如果我们不提供构造和析构,编译器会提供,且是空实现
- 构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无需手动。
- 析构函数:主要作用在于对象销毁前系统自动调用,执行一些清理工作
构造函数语法:类名(){}
- 构造函数没有返回值也不写void
- 函数名称与类名相同
- 构造函数可以有参数,因此可以发生重载
- 程序在调用对象时候会自动调用构造,无需手动且只调用一次
析构函数语法~类名(){}
- 析构函数,没有返回值也不写void
- 函数名称与类名相同,在前加 ~
- 析构函数不可以有参数,因此不可以重载
- 程序在销毁对象时候会自动调用析构,无需手动且只调用一次
#include<bits/stdc++.h>
using namespace std;
//1.构造函数初始化
class Person
{
public:
//1.1 构造函数
//无返回值无void
//函数名就是类名
//有参数可重载
Person()
{
cout<<"Person构造函数的调用"<<endl;
}
//1.2析构函数
~Person()
{
cout<<"Person的析构函数调用"<<endl;
}
};
void test01()
{
Person p;
}
int main()
{
Person p;
test01();
}
4.2.2 构造函数的分类及调用
- 两种分类方式:
按参数分为:有参构造和无参构造
按类型分为:普通构造和拷贝构造 - 三种调用方式:
括号法
显示法
隐式转换法
#include<bits/stdc++.h>
using namespace std;
//构造函数分类
//无参构造(默认构造)&有参构造
//普通构造&拷贝构造
class Person
{
public:
int age;
Person()
{
cout<<"Person的无参构造函数调用"<<endl;
}
Person(int a)
{
age=a;
cout<<"Person的有参构造函数调用"<<endl;
}
//拷贝构造函数
Person (const Person &p)
{
age=p.age;
cout<<"Person的拷贝构造函数调用"<<endl;
}
};
//调用
void test01()
{
//1.括号法
//Person p1;//默认构造函数调用
//Person p2(10);//有参构造函数
//Person p3(p2);//拷贝构造函数
//注意事项
//调用默认构造函数时候,不要加()
//因为下面这行代码,编译器会认为是一个函数声明,不会认为在创建对象
//Person p1();
//cout<<"p2的年龄为:"<<p2.age<<endl;
//cout<<"p3的年龄为:"<<p3.age<<endl;
//2.显示法
Person p1;
Person p2=Person(10);//有参构造
Person p3=Person (p2);//拷贝构造
Person(10);//匿名对象 特点:当前行执行结束后,系统会立即回收掉匿名对象 、、
//注意事项2
//不要利用拷贝构造函数 初始化匿名对象
//编译器会认为 Person(p3)==Person p3;(对象声明)
//Person(p3);
//3.隐式转换法
Person p4=10;//相当于Person p4=Person(10);
//有参构造
Person p5=p4; //拷贝构造
}
int main()
{
test01();
}
4.2.3 拷贝构造函数调用时机
C++中拷贝构造函数调用时机通常有三种情况
- 使用一个已经创建完毕的对象来初始化一个新对象
- 值传递的方式给函数参数传值
- 以值方式返回局部对象
示例
#include<bits/stdc++.h>
using namespace std;
class Person
{
public:
Person()
{
cout<<"Person默认构造函数调用"<<endl;
}
Person(int age)
{
cout<<"Person有参构造函数调用"<<endl;
m_Age=age;
}
Person(const Person & p)
{
cout<<"Person拷贝构造函数调用"<<endl;
m_Age=p.m_Age;
}
~Person()
{
cout<<"Person析构函数调用"<<endl;
}
int m_Age;
};
void test01()
{
Person p1(20);
Person p2(p1);
cout<<"p2的年龄为:"<<p2.m_Age<<endl;
}
void dowork(Person p)
{
}
Person dowork2()
{
Person p1;
return p1;
}
void test02()
{
Person p;
dowork(p);
}
void test03()
{
Person p=dowork2();
}
int main()
{
//test01();
//test02();
test03();
}
4.2.4 构造函数的调用规则
默认情况下,C++编译器至少给一个类添加3个函数
- 默认构造函数(无参,函数体为空)
- 默认析构函数(无参,函数体为空)
- 默认拷贝构造函数,对属性进行值拷贝
规则如下:
- 如果用户定义有参构造函数,C++不再提供默认无参构造,但是会提供拷贝构造
- 如果用户定义拷贝构造函数,C++不会再提供其他构造函数
#include<bits/stdc++.h>
using namespace std;
class Person
{
public:
Person()
{
cout<<"Person的默认构造函数调用"<<endl;
}
Person(int age)
{
cout<<"Person的有参构造函数调用"<<endl;
m_Age=age;
}
Person(const Person & p)
{
cout<<"Person的拷贝构造函数调用"<<endl;
m_Age=p.m_Age;
}
~Person()
{
cout<<"Person的析构函数调用"<<endl;
}
int m_Age;
};
void test01()
{
Person p;
p.m_Age=18;
Person p2(p);
cout<<"p2的年龄为:"<<p2.m_Age<<endl;
}
int main()
{
test01()
}
4.2.5 深拷贝与浅拷贝
浅拷贝:简单的赋值拷贝操作
深拷贝:在堆区重新申请空间,进行拷贝操作
- new创建返回的是一个地址(这个地址保存了Height的值),所以需要用指针地址接收。
#include<bits/stdc++.h>
using namespace std;
class Person
{
public:
Person()
{
cout<<"Person的默认构造函数调用"<<endl;
}
Person(int age,int height)
{
m_Age=age;
m_Height = new int(height);
cout<<"Person的有参构造函数调用"<<endl;
}
//自己实现拷贝构造函数,解决浅拷贝带来的问题
Person(const Person &p)
{
cout<<"Person拷贝构造函数调用"<<endl;
m_Age=p.m_Age;
//m_Height=p.m_Heiget 编译器默认实现就是这行代码
//深拷贝操作
m_Height=new int(*p.m_Height) ;
}
~Person()
{
//析构代码,将堆区开辟数据做释放操作
if(m_Height!=NULL)
{
delete m_Height;
m_Height=NULL;
}
cout<<"Person的析构函数调用"<<endl;
}
int m_Age;
int *m_Height;
};
void test01()
{
Person p1(18,180);
cout<<"p1的年龄:"<<p1.m_Age<<"身高为:"<<*p1.m_Height<<endl;
Person p2(p1);//编译器提供了拷贝构造函数(浅拷贝)
cout<<"p2的年龄:"<<p2.m_Age<<"身高为:"<<*p2.m_Height<<endl;
}
int main()
{
test01();
}
4.2.6 初始化列表
作用:C++提供了初始化列表语法,用来初始化属性
语法:构造函数():属性1(值1),属性2(值2)...{}
#include<bits/stdc++.h>
using namespace std;
class Person
{
public:
//传统初始化操作
/*Person(int a,int b,int c)
{
m_A=a;
m_B=b;
m_C=c;
} */
//初始化列表初始化属性
Person(int a,int b,int c):m_A(a),m_B(b),m_C(c){}
int m_A;
int m_B;
int m_C;
};
void test01()
{
//Person p(10,20,30);
Person p(2,1,6);
cout<<"m_A:"<<p.m_A<<endl;
cout<<"m_B:"<<p.m_B<<endl;
cout<<"m_C:"<<p.m_C<<endl;
}
int main()
{
test01();
}
4.2.7 类对象作为类成员
C++类中的成员可以是另一个类的对象,我们称该成员为对象成员
class A{}
class B
{
A a;
}
#include<bits/stdc++.h>
using namespace std;
//类对象作为类成员
//手机类
class Phone
{
public:
Phone(string pName)
{
m_PName=pName;
cout<<"Phone"<<endl;
}
~Phone()
{
cout<<"Phone的析构函数调用"<<endl;
}
string m_PName;
};
//人类
class Person
{
public:
//Phone m_Phone=pName 隐式转换法
Person(string name,string pName):m_Name(name),m_Phone(pName)
{
cout<<"Person"<<endl;
}
~Person()
{
cout<<"Person的析构函数调用"<<endl;
}
//姓名
string m_Name;
//手机
Phone m_Phone;
};
//当其他类对象作为本类成员,构造时先构造类对象,在构造自身
//析构的顺序与构造的相反
void test01()
{
Person p("太一","茉莉牌手机");
cout<<p.m_Name<<"拿着"<<p.m_Phone.m_PName<<endl;
}
int main()
{
test01();
}
4.2.8 静态成员
静态成员就是在成员变量和成员函数前加上关键字static,成为静态成员
分类:
- 静态成员变量
- 所有对象共享一份数据
- 在编译阶段分配内存(程序运行之前,内存分配在全局区)
- 类内声明,类外初始化
- 静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量
静态成员变量
#include<bits/stdc++.h>
using namespace std;
//静态成员变量
class Person
{
public:
//1共享同一份数据
//2编译时分配内存
//3类内声明 类外初始化
static int m_A; //类内声明
//静态成员变量也有访问权限
private:
static int m_B;
};
int Person::m_A=100;//类外初始化
int Person::m_B=200;
void test01()
{
Person p;
cout<<p.m_A<<endl;//100
Person p2;
p.m_A=200;
cout<<p.m_A<<endl;//200
}
void test02()
{
//静态成员变量不属于某个对象上,所有对象都共享同一份数据
//因此静态成员变量有两种访问方式
//1.通过对象进行访问
Person p;
cout<<p.m_A<<endl;
//2.通过类名进行访问
cout<<Person::m_A<<endl;
//cout<<Person::m_B<<endl;//在私有下声明因此类外不能访问
}
int main()
{
test01();
test02();
}
静态成员函数
#include<bits/stdc++.h>
using namespace std;
//静态成员函数
class Person
{
public:
//静态成员函数
static void func()
{
m_A=100;//静态成员函数可以访问静态成员变量
//m_B=200;//静态函数不能访问非静态变量
cout<<"static void func调用"<<endl;
}
static int m_A;//静态成员变量
int m_B;//非静态
private:
static void func1()
{
cout<<"static void func1调用"<<endl;
}
};
int Person::m_A=0;
void test01()
{
//1.通过对象
Person p;
p.func();
//2.通过类名
Person::func();
//Person::func1(); 类外私有无法访问
}
int main()
{
test01();
}