1、构造函数和析构函数
对象的初始化和清理是非常重要的安全问题
c++利用了构造函数和析构函数解决上述问题,这个函数编译器自动调用。如果程序员没有提供构造和析构函数,编译器会提供默认的构造和析构函数,都是空实现。
- 构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无需手动调用
- 析构函数:主要作用在于对象销毁前系统自行调用,执行一些清理工作
构造函数语法:类名(){}
- 构造函数,没有返回值也不写void
- 函数名称和类名相同
- 构造函数可以有参数,因此可以发送重载
- 程序在调用对象时会自动调用构造函数,无需手动调用,且只调用一次
析构函数语法:~类名(){}
- 析构函数,没有返回值也不写void
- 函数名称和类名相同,并在前面加~
- 不可以有参数,不能发生重载
- 程序在对象销毁前自动调用析构函数,无需手动调用,且只调用一次
class Person
{
public:
//构造函数
Person()
{
cout << "构造函数的调用" << endl;
}
//析构函数
~Person()
{
cout << "析构函数的调用" << endl;
}
};
void test01()
{
Person p;
}
int main()
{
test01();
Person p1;
system("pause");
return 0;
}
构造函数的调用
析构函数的调用
构造函数的调用
请按任意键继续. . .
前两条是调用test01时会自动调用构造函数和析构函数
第三条是main函数中运行时先调用构造函数,之后按任意键,结束main函数,此时自动调用析构函数,如下所示:
构造函数的调用
析构函数的调用
构造函数的调用
请按任意键继续. . .
析构函数的调用
2、构造函数的分类及调用
两种分类方式:
按参数分为:有参构造函数和无参构造函数
按类型分为:普通构造和拷贝构造
三种调用方式
括号法
显示法
隐式转换法
//构造函数的分类及调用
class Person
{
public:
//构造函数
//按参数分为:有参构造函数和无参构造函数
Person()
{
cout << "无参构造函数的调用" << endl;
}
Person(int a)
{
age = a;
cout << "有参构造函数的调用" << endl;
}
//按类型分为:普通构造和拷贝构造
Person(const Person &p)
{
age = p.age;//将传入的人身上的属性拷贝过来
cout << "拷贝构造函数的调用" << endl;
}
int age;
//析构函数
~Person()
{
cout << "析构函数的调用" << endl;
}
};
//构造函数的调用
void test01()
{
//括号法
Person p1;//默认构造函数的调用 注意调用默认构造函数不要加括号
Person p2(10);//有参构造函数的调用
Person p3(p2);//拷贝构造函数调用
cout << "p2的年龄" << p2.age << endl;
cout << "p3的年龄" << p3.age << endl;
//显示法
Person p4;
Person p5 = Person(20);//有参构造调用
Person p6 = Person(p5);//拷贝构造调用
cout << "p5的年龄" << p5.age << endl;
cout << "p6的年龄" << p6.age << endl;
Person(30);//匿名对象,特点:当前执行结束后,系统立马回收掉匿名对象
//不要利用拷贝构造函数初始化匿名对象
//隐式构造法
Person p7 = 40;//有参构造调用
Person p8 = p7;//拷贝构造调用
}
int main()
{
test01();
system("pause");
return 0;
}
无参构造函数的调用
有参构造函数的调用
拷贝构造函数的调用
p2的年龄10
p3的年龄10
无参构造函数的调用
有参构造函数的调用
拷贝构造函数的调用
p5的年龄20
p6的年龄20
有参构造函数的调用
析构函数的调用
有参构造函数的调用
拷贝构造函数的调用
p7的年龄40
p8的年龄40
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用
请按任意键继续. . .
3、拷贝构造函数的调用时机
c++中拷贝构造函数调用时间通常有三种情况
- 使用一个已经创建的完毕的对象来初始化一个新对象
- 值传递的方式给函数参数传值
- 以值方式返回局部对象
//拷贝构造函数的调用时机
class person
{
public:
int m_age;
person()
{
cout << "默认构造函数调用" << endl;
}
person(int age)
{
m_age = age;
cout << "有参构造函数调用" << endl;
}
person(const person &p)
{
m_age = p.m_age;
cout << "拷贝构造函数调用" << endl;
}
};
//使用一个已经创建的完毕的对象来初始化一个新对象
void test01()
{
person p1(20);
person p2(p1);
}
//值传递的方式给函数参数传值
void doWork(person p)
{
cout << "值传递" << endl;
}
void test02()
{
person p;
doWork(p);
}
//以值方式返回局部对象
person doWork1()
{
person p3;
return p3;
}
void test03()
{
person p4 = doWork1();
}
int main()
{
test01();
system("pause");
return 0;
}
4、构造函数的调用规则
默认情况下,c++编译器至少给一个类添加3个函数
1、默认构造函数(无参,函数体为空)
2、默认析构函数(无参,函数体为空)
3、默认拷贝构造函数,对属性值进行拷贝
构造函数调用规则如下:
- 如果用户定义有参构造函数,c++不在提供默认无参构造函数,但会提供默认拷贝构造函数
- 如果用户定义拷贝构造函数,c++不在提供其他构造函数
5、深拷贝和浅拷贝
浅拷贝:简单的赋值拷贝操作
深拷贝:在堆区重新申请空间,进行拷贝操作
!!!如果属性有在堆区开辟的,一定要自己提供拷贝构造函数,防止浅拷贝带来的问题
using namespace std;
class person
{
public:
int m_age;
int *m_hight;
person()
{
cout << "默认构造函数调用" << endl;
}
person(int age,int hight)
{
m_age = age;
m_hight = new int(hight);
cout << "有参构造函数调用" << endl;
}
person(const person &p)
{
m_age = p.m_age;
m_hight = new int(*p.m_hight);
cout << "拷贝构造函数调用" << endl;
}
~person()//将堆区的开辟的数据做释放操作
{
if (m_hight != NULL)
{
delete m_hight;
m_hight = NULL;
}
cout << "析构构造函数调用" << endl;
}
};
void test01()
{
person p(18, 180);
person p1(p);
cout << "p1的年龄" << p1.m_age << endl;
cout << "p1的身高" << *p1.m_hight << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
6、初始化列表
作用:c++提供了初始化列表语法,用来初始化属性
语法:构造函数():属性1(值1),属性2(值2)....{}
class person
{
public:
int m_age;
int m_hight;
//传统初始化
/*person(int age,int hight)
{
m_age = age;
m_hight = hight;
cout << "有参构造函数调用" << endl;
}*/
//初始化列表
person(int age, int hight) :m_age(age), m_hight(hight)
{
}
~person()//将堆区的开辟的数据做释放操作
{
cout << "析构构造函数调用" << endl;
}
};
void test01()
{
person p(18, 200);
cout << "p的年龄" << p.m_age << endl;
cout << "p的身高" << p.m_hight << endl;
person p1(p);
cout << "p1的年龄" << p1.m_age << endl;
cout << "p1的身高" << p1.m_hight << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
7、类对象作为类成员
c++类中的成员可以是另一个类的对象,我们称该成员为对象成员
class phone
{
public:
phone(string pname)
{
m_pname = pname;
}
string m_pname;
~phone()
{
}
};
class person
{
public:
string m_name;
phone m_phone;
person(string name, string pname): m_name(name), m_phone(pname)
{
cout << m_name << endl;
cout << m_phone.m_pname << endl;
}
~person()
{
cout << "析构构造函数调用" << endl;
}
void playgame()
{
cout << m_name << "岁" << m_phone.m_pname << "手机" << endl;
}
};
void test01()
{
person p("liuHI","phone");
p.playgame();
}
int main()
{
test01();
system("pause");
return 0;
}
8、静态成员
静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员
静态成员分为
- 静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存
- 类内声明,类外初始化
class Person
{
public:
static int m_A; //静态成员变量
//静态成员变量特点:
//1 在编译阶段分配内存
//2 类内声明,类外初始化
//3 所有对象共享同一份数据
private:
static int m_B; //静态成员变量也是有访问权限的
};
int Person::m_A = 10;
int Person::m_B = 10;
void test01()
{
//静态成员变量两种访问方式
//1、通过对象
Person p1;
p1.m_A = 100;
cout << "p1.m_A = " << p1.m_A << endl;
Person p2;
p2.m_A = 200;
cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
cout << "p2.m_A = " << p2.m_A << endl;
//2、通过类名
cout << "m_A = " << Person::m_A << endl;
//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}
int main() {
test01();
system("pause");
return 0;
}
- 静态成员函数
- 所有对象共用同一个函数
- 静态成员函数只能访问静态成员变量
class person
{
public:
string m_name;
static void func()
{
m_A = 100;//可以访问类内静态成员变量
//m_B = 200;//报错,不可以访问其他变量
cout << "静态成员函数调用" << endl;
}
static int m_A; //类内声明,类外初始化
int m_B;
private:
static void func2()
{
cout << "static void func2()调用" << endl;
}
};
int person::m_A = 0;
void test01()
{
//通过对象调用
person p;
p.func();
//通过类名访问
person::func();
//person::func2();//类外不能访问私有静态成员函数
}
int main()
{
test01();
system("pause");
return 0;
}
静态成员函数调用
静态成员函数调用
请按任意键继续. . .