类和对象——对象的初始化和清理

本文为观看 C++黑马程序员的学习笔记。

构造函数和析构函数

构造函数：进行初始化操作

析构函数：进行清理操作

构造函数语法：类名（）{}

构造函数，没有返回值，也不写void
函数名称与类名相同
构造函数可以有参数，因此可以重载
程序在调用对象时，会自动调用构造，无需手动调用一次，而且只会调用一次

析构函数语法：~类名（）{}

析构函数，没有返回值，也不写void
函数名称与类名相同，在名称前加上符号~
析构函数不可以有参数，因此不可以发生重载
程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次

构造函数和析构函数语法：

class Person
{
public://构造函数Person(){cout << "Person的构造函数调用" << endl;}//析构函数~Person(){cout << "Person的析构函数调用" << endl;}
};

函数的分类及调用

两种分类方式：

按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造

三种调用方式：

括号法
显示法
隐式转换法

代码有问题，需要改正

拷贝构造函数调用时机

拷贝构造函数调用时机，有3中情况

使用一个创建完毕的对象来初始化一个新对象
值传递的方式给函数参数传值
以值方式返回局部对象

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
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; //m_Age 一定要记得声明
};//1、使用一个创建完毕的对象来初始化一个新对象
void test01()
{Person p1(20);Person p2(p1);cout << "p2的年龄为： " << p2.m_Age << endl;
}//2、值传递的方式给函数参数传值void  doWork(Person p)
{}void test02()
{Person p;doWork(p);
}//3、以值方式返回局部对象Person doWork2()
{Person p1;cout << (int*)&p1 << endl;return p1;
}void test03()
{Person p = doWork2();cout << (int*)&p << endl;
}int main()
{//test01();test02();//test03();system("pause");
}

构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

1.默认构造函数（无参，函数体为空）

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

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

构造函数调用规则：

如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
如果用户定义拷贝构造函数，c++不会再提供其他构造函数

#define _CRT_SECURE_NO_WARNINGS 1
using namespace std;
#include <iostream>//默认情况下，c++编译器至少给一个类添加3个函数//1.默认构造函数（无参，函数体为空）//2.默认析构函数（无参，函数体为空）//3.默认拷贝构造函数，对属性进行值拷贝//如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
//如果用户定义拷贝构造函数，c++不会再提供其他构造函数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;
//}void test02()
{Person p(28);Person p2(p);cout << "p2的年龄为： " << p2.m_Age << endl;
}int main()
{//test01();test02();system("pause");
}

深拷贝与浅拷贝

深拷贝，面试经典考题

浅拷贝：简单的复制拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
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_Height;编译器默认实现的就是这行代码,是浅拷贝//深拷贝操作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,160);cout << "p1的年龄为： " << p1.m_Age << "  p1的身高为： " << *p1.m_Height << endl;Person p2(p1);cout << "p2的年龄为： " << p2.m_Age << "  p2的身高为： " << *p2.m_Height << endl;
}int main()
{test01(); 
}

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

初始化列表

作用：初始化列表语法，用来初始化属性

语法：构造函数（）：属性1（值1），属性2（值2）...{ }

#define _CRT_SECURE_NO_WARNINGS 1
using namespace std;
#include <iostream>//初始化列表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(10, 20, 30); // 创建对象cout << "m_A = " << p.m_A << endl;cout << "m_B = " << p.m_B << endl;cout << "m_B = " << p.m_B << endl;}int main()
{test01();system("pause");
}

类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员

例如：

class A{}
class B
{A  a;
}

上述，B类中有对象A作为成员，A为对象成员。

问：A和B的构造和析构顺序是谁先谁后？

答：构造是先A后B，析构顺序相反。

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
using namespace std;//类对象作为类成员// 手机类
class Phone
{public:Phone(string pName){cout << "Phone的构造函数调用" << endl;m_PName = pName;}~Phone(){cout << "Phone的析构函数调用" << endl;}//手机品牌名称string m_PName;
};// 人类
class Person  // Person为B
{
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;  // Phone为A
};//void test01()
{Person p("张三" , "苹果MAX");cout << p.m_Name << "拿着：" << p.m_Phone.m_PName << endl;
}int main()
{test01();system("pause");
}

静态成员

静态成员，就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：静态成员变量、静态成员函数

1、静态成员变量特点：

所有对象共享同一份数据
在编译阶段分配内存
类内声明，类外初始化

静态成员变量不属于某个对象，所有对象都共享同一份数据

所以静态成员变量有两种访问方式

通过对象进行访问
通过类名进行访问

静态成员变量也是有访问权限的

公有作用域类外可以访问
私有作用域类外不可以被访问

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;//静态成员变量
class Person
{
public://所有对象共享同一份数据//在编译阶段分配内存//类内声明，类外初始化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;Person p2;p2.m_A = 200;  //100 ? 200cout << p.m_A << endl;  //所有对象共享同一份数据
}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();system("pause");return 0;
}

2、静态成员函数特点：

所有对象共享同一个函数
静态成员函数只能访问静态成员变量

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
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 func2(){cout << "static void func2调用" << endl;}
};// 有两种访问方式
void test01()
{//1、通过对象访问/*person p;p.func();*///2、通过类名访问Person::func();//Person::func2(); // 类外访问不到私有静态成员函数
}int main()
{test01();
}