C++的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置

构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

• 一个对象或者变量没有初始状态，对其使用后果是未知
• 使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

C++利用构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象的初始化和清理工作，对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器提供的构造函数和析构函数将会是空实现

• 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用
• 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作

构造函数语法：类名 () {}

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

析构函数语法：~类名 () {}

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

class person { private:  string name; public:  person()  {  cout << "调用构造函数" << endl;  name = "张三";  }  ~person()  {  cout << "调用析构函数" << endl;  }  string getname()  {  return name;  } }; int main() {  person a1;  cout << a1.getname() << endl;  system("pause");  return 0; }

输出

调用构造函数 张三 请按任意键继续. . . 调用析构函数

构造函数分类及调用

两种分类方式：

• 按参数分为：无参构造（默认构造）和有参构造
• 按类型分为：普通构造和拷贝构造

三种调用方式：

• 括号法
• 显示法
• 隐式转换法

注意事项：

• 调用默认构造函数时，不要加()，因为编译器会认为是一个函数声明，不会认为在创建对象
• 不要利用拷贝构造函数初始化匿名对象，编译器会认为时一个对象声明，会报重定义的错误

• • person(c1) = person c1;

//括号法 person a0;//调用默认构造函数时，不要加()，因为编译器会认为是一个函数声明 person a1("张三");//有参构造 person a2(a1);//拷贝构造 //显示法 person b1; person b2 = person("张三");//有参构造 person b3 = person(b2);//拷贝构造 person("张三");//匿名对象，当前行执行结束后，会被系统立即回收 //隐式转换法 person c1 = "张三";//会报错,暂时不知道原因 person c2 = c1;//编译器转换为person c2 = person(c1);

拷贝构造函数的调用时机

C++中拷贝构造函数调用时机：

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

person test(person a) {  return a; }; int main() {  //使用一个已经创建完毕的对象来初始化一个新对象  person p1("张三");  person p2(p1);  //值传递的方式给函数参数传值  test(p1);  //以值方式返回局部对象  person p3 = test(p1);  return 0; }

构造函数调用规则

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

• 默认构造函数（无参，函数体为空）
• 默认析构函数（无参，函数体为空）
• 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

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

class person { private:  string name; public:  person(const string a)  {  cout << "有参构造" << endl;  name = a;  }  person(const person& a)  {  cout << "拷贝构造" << endl;  name = a.name;  } }; int main() {  person p0;//没有合适的默认构造函数可用  person p1("张三");  person p2(p1);  return 0; }

深拷贝与浅拷贝

深浅拷贝是面试经典问题

• 浅拷贝：简单的赋值拷贝工作
• 深拷贝：在堆区重新申请空间，进行拷贝操作

析构：将堆区开辟的数据做释放操作

浅拷贝问题：堆区内存重复释放

解决方法：自己实现一个拷贝函数，解决浅拷贝带来的问题

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

class person { private:  string* name; public:  person(const string a)  {  cout << "有参构造" << endl;  name = new string(a);  cout << *name << endl;  }  //深拷贝  person(const person& a)  {  cout << "拷贝构造" << endl;  name = new string(*a.name);  cout << *name << endl;  }  ~person()  {  cout << "调用析构函数" << endl;  if (name != NULL)  {  delete name;  name = NULL;  }  } }; int main() {  person p1("张三");  person p2(p1);  return 0; }

初始化列表

C++提供了初始化列表语法，用来初始化属性

语法：构造函数():属性1(值1),属性2(值2)...{}

注意冒号:在构造函数形参列表之后

class person { public:  person(const string a, int b) :name(a), age(b)  {  cout << "初始化列表" << endl;  }  string name;  int age; }; int main() {  person p1("张三", 10);  return 0; }

类对象作为类成员

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

当其他类对象作为本类成员，构造的时候先构造类对象，再构造自身，析构的顺序与构造相反

class Phone { public:  Phone()  {  cout << "对象构造" << endl;  }  ~Phone()  {  cout << "对象析构" << endl;  }  string phone; }; class Person { public:  Person()  {  cout << "本类构造" << endl;  }  ~Person()  {  cout << "本类析构" << endl;  }  string name;  Phone phone; }; int main() {  Person a;  return 0; }

输出结果

对象构造 本类构造 本类析构 对象析构

静态成员

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

静态成员分为：

• 静态成员变量

• • 所有对象共享同一份数据
  • 在编译阶段分配内存（全局区）
  • 类内声明，类外初始化
  • 静态成员变量，不属于某个对象上，所有对象都共享同一份数据

• 静态成员函数

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

• • • 可以访问静态成员变量：不属于某一个对象，是共享的
    • 无法访问非静态成员变量：无法区分到底是哪个对象的属性

• • 也是有访问权限的

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

• 通过对象进行访问：对象.成员变量
• 通过类名进行访问：类名::成员变量

class Phone { public:  //类内定义  static string phone; private:  static string name;//静态成员变量也是有访问权限的 }; //类外初始化 string Phone::phone = "110";//通过类名访问 int main() {  Phone a;  a.phone = "119";//通过对象访问  cout << a.phone << endl;  return 0; }