C++ ——构造函数

1、作用：创建对象时，给对象的属性进行初始化

2、特点

        （1）构造函数与类同名

        （2）如果没有显式给出构造函数，编译器会给出默认的构造函数（参数为空，并且函数体也为空）；如果给出任意的构造函数，系统默认的构造函数就不存在了

        （3）有返回值，但是不写返回值类型，也不可以写void

        （4）构造函数是在创建对象时自动调用

3、构造函数支持函数重载

4、构造函数也支持函数默认值

1、无参构造函数

编译器默认的构造函数：

    类名(){

   }

#include <iostream>

using namespace std;

class Phone{

private:  

    string brand;  //品牌

    string color;  //颜色

    double price;  //价格

public:

    void play_music() {

        cout<<"播放音乐"<<endl;

    }

    void play_video(){

        cout<<"播放视频"<<endl;

    }

    //无参构造函数

    Phone(){

        cout<<"构造函数"<<endl;

    }

};

int main(){

    //无参构造函数

    Phone p1;

    return 0;

}

2、有参构造函数

#include <iostream>

using namespace std;

class Phone{

private: 

    string brand;  //品牌

    string color;  //颜色

    double price;  //价格

public:

    void play_music() {

        cout<<"播放音乐"<<endl;

    }

    void play_video(){

        cout<<"播放视频"<<endl;

    }

    //有参构造函数

    Phone(string a,string b,double c=2995){

        brand=a;

        color=b;

        price=c;

    }

};

int main(){

    //有参构造函数（栈内存对象）

    Phone p2("vivo","红",9);

    //有参构造函数（堆内存对象）

    Phone*p3=new Phone("oppo","蓝",4);

    delete p3;

    p3=NULL;

    return 0;

}

3、构造初始化列表

构造初始化列表：就是构造函数的一种简便写法

注意：构造初始化列表与构造函数不能同时出现

#include <iostream>

using namespace std;

class Person{

private: 

    int id;

    string name;

    string sex;

    bool flag;

public:

    //构造初始化列表

    Person(int id,string name,string sex,bool flag)

        :id(id),name(name),sex(sex),flag(flag){}

    void show(){

        cout<<id<<name<<sex<<endl;

    }

};

int main(){

    Person p1(1001,"张三","男",true);

    p1.show();

    return 0;

}

4、拷贝构造函数

作用：用于实现对象的拷贝创建 

特点：

        （1）拷贝构造函数与构造函数构成重载（拷贝构造函数也是与类同名）

        （2）如果不给出拷贝构造函数，编译器会给出默认的拷贝构造函数，完成对象之间的值复制；如果给出拷贝构造函数，编译器就不会提供默认的拷贝构造函数

        （3）拷贝构造函数的参数类型是对象的引用或者是const修饰的对象的引用

        （4）拷贝构造函数是在拷贝创建对象时自动调用

注意：对象之间是相互独立的，对象之间的属性也是相互独立的

4.1 浅拷贝 

编译器默认给出的拷贝构造函数，完成的就是浅拷贝，会完成对象之间简单的值复制 

#include <iostream>

using namespace std;

class Person{

private:  

    int id;

    string name;

    string sex;

    bool flag;

public:

    //构造初始化列表

    Person(int id,string name,string sex,bool flag)

        :id(id),name(name),sex(sex),flag(flag){}

    //编译器给出的默认的拷贝构造函数（手写出来的）----->浅拷贝 

    Person(const Person&p){

        id=p.id;

        name=p.name;

        sex=p.sex;

        flag=p.flag;

    }

    void show(){

        cout<<id<<name<<sex<<endl;

    }

};

int main(){

    Person p1(1001,"张三","男",true);  //调用有参的构造函数

    p1.show();

//    //方法一：

//    Person&pp=p1;

//    Person p2(pp);

    //方法二：

    Person p2(p1);  //调用拷贝构造函数

    p2.show();

    return 0;

}

默认拷贝构造函数存在安全隐患：如果成员变量是指针类型，两个对象的指针类型属性指向同一个内存空间，破坏了对象的独立性，那么这种拷贝叫浅拷贝 

解决方法：使用深拷贝

4.2 深拷贝

实现方式：创建对象时，指针属性要有自己独立的区域；拷贝对象时，由地址拷贝变成内容拷贝

#include <iostream>

#include <string.h>

using namespace std;

class Animal{

private:

    string kind;  //种类

    double weight;  //体重

    char*hobby;  //爱好

public:

    //构造函数---->深拷贝

    Animal(string k,double w,char*h){

        kind=k;

        weight=w;

        //创建对象时，指针属性要有自己独立的区域

        hobby=new char[20];

        strcpy(hobby,h);  //使用strcpy前，需要引入string.h头文件

    }

    //展示信息

    void show(){

        cout<<"种类:"<<kind<<",体重:"<<weight<<",爱好:"<<hobby<<endl;

    }

    //kind读接口

    string get_kind(){

        return kind;

    }

    //拷贝构造函数---->深拷贝

    Animal(const Animal&c){

        kind=c.kind;

        weight=c.weight;

        //拷贝对象时，由地址拷贝变成内容拷贝

        hobby=new char[20];

        strcpy(hobby,c.hobby);

    }

};

int main(){

    char h[20]="eat fish";

    Animal cat1("小猫",12,h);  //调用有参构造函数

    cat1.show();

    Animal cat2(cat1);  //调用拷贝构造函数

    cat2.show();

    return 0;

}

4.3 隐式调用构造函数

截止到目前，对于构造函数的调用都是显式调用

隐式调用构造函数的出现情况：

        （1）等号赋值时，等号左侧是对象类型，等号右边恰好是对象构造函数所需要的参数类型，这时就会把右侧值传入到构造函数中，相当于隐式调用构造函数

#include <iostream>

using namespace std;

class Test{

private:

    int number;

public:

    Test(int number)

        :number(number){}

    int get_number(){

        return number;

    }

};

int main(){

//    Test t1(100);  //显示调用构造函数

//    cout<<t1.get_number()<<endl;

//    Test*t2=new Test(8);  //显示调用构造函数

//    cout<<t2->get_number()<<endl;

//    delete t2;

//    t2=NULL;

//    Test t3(t1);  //显示调用构造函数

//    cout<<t3.get_number()<<endl;

    Test t4=9;  //隐式调用构造函数

    cout<<t4.get_number()<<endl;

    Test t5=t4;  //隐式调用构造函数

    cout<<t5.get_number()<<endl;

    return 0;

}

        （2）隐式调用构造函数，一般在程序员不自知的情况下产生的，需要规避掉，可以用explicit关键字屏蔽

class Test{

private:

    int number;

public:

    explicit Test(int number)

        :number(number){}

    int get_number(){

        return number;

    }

};