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;
}