细说C++中构造函数

一、构造函数的定义与形式

C++中定义的与类名相同的成员函数，这种成员函数就叫做构造函数。

普通构造函数:

class 类名
{
    类名(形参)
    {
        函数的函数体
    }
};
//案例
class A()
{
public:
    A(int a)
    {
        this.a = a;
    }
private:
    int a;
};

拷贝构造函数:

由己存在的对象,创建新对象。也就是说新对象,不由构造器来构造,而是由拷贝 构造器来完成。拷贝构造器的格式是固定的。

class 类名
{
    类名(const 类名 &obj)
    {
        cout << "拷贝构造" << endl;
    }
};
//案例
class B
{
public:
    B(const B &obj)
    {
        cout << "这是拷贝构造函数" << endl;
    }
    ~B(){}
private:
};

2、构造函数的调用与规则

调用

自动调用：一般情况下C++编译器会自动调用构造函数.
手动调用：在一些情况下则需要手工调用构造函数.

规则

• 在对象创建时自动调用,完成初始化相关工作。
• 无返回值,与类名同,默认无参,可以重载,可默认参数。
• 一经实现,默认不复存在。

3、构造函数的类别

我们都知道，构造函数分为无参构造，有参构造和拷贝构造。

形式与案例

class ABC
{
public:
    ABC()
    {
        a = 0;
        b = 0;
        cout << "这是无参构造函数" << endl;
    }

    ABC(int a, int b, int c)
    {
        this.a = a;
        this.b = b;
        this.c = c; 
        cout << "这是有参构造函数" << endl;
    }

    ABC(const ABC &another_obj)
    {
        cout << "这是拷贝构造函数" << endl
    }

    ~ABC()
    {
    }
private:
    int a;
    int b;
};

4、构造函数的应用场景

无参与有参构造场景

class A
{
public:
    A()
    {
        cout << "我是无参构造" << endl;
    }

    A(int a)
    {
        this a = a;
    }

    A(int a, int b =0)
    {
        this a = a;
        this.b = b;
    }

private:
    int a;
    int b;
};

int main()
{
    A a; //调用无参构造
    A a(10);调用只用一个参数的有参构造函数
    A a(100, 100), //调用有参构造
    return 0;
}

拷贝构造函数的应用场景

class NBA
{
public:
    NBA()
    {
        cout << "我是无参构造" << endl;
    }

    NBA(int a, int b)
    {
        this.a = a; 
        this.b = b;
        cout << "我是有参构造" << endl;
    }

    NBA(const NBA &obj)
    {
        cout << "我是拷贝构造" << endl;
        n = obj.n;
    }

    ~NBA()
    {
        cout << "我是析构函数" << endl;
    }

    void p_a()
    {
        cout << "我是普通成员函数" << endl;
        cout << "a="  << a << endl;
    }
private:
    int n;
};

//拷贝函数第一个应用场景
int mian01()
{
    NBA na(10);
    NBA nba = na;  //调用对象 na 初始化对象 nba  
    return 0;
}

//拷贝构造应用的第二个场景
int main02()
{
    NBA a(100);
    NBA nba(a);  //调用对象 na 初始化对象 nba  
    return 0;
}

//拷贝构造应用的第三个场景
void func(NBA nba) 
{
    nba.p_a();
}

int main03()
{
    NBA a(20); 
    func(a);
    return 0;
}

//拷贝构造应用的第四个场景
NBA func2(void)
{
    NBA temp(100, 200);
    temp.p_a();
    //在此刻 会创建一个匿名的对象来接收temp局部对象。
    //通过匿名的拷贝构造函数来构造匿名对象
    return temp;                
}

int main04()
{
    //func2 函数 的返回值是一个Test 是一个匿名的对象，
    // 当func2返回之后会有一个匿名对象生成，但是这个匿名对象没有任何变量接收，也没有使用 
    //编译器认为这个匿名没有意义，就会即可给他销毁
    func2(); 
    return 0;
}

//拷贝构造应用的第五个场景
int main05()
{
    //如果在fun2函数返回之后，会创建一个匿名对象， 如果在外部有一个变量给他接收
    //实际这个a 就是那个匿名对象， 匿名对象转正了，有了自己的名字叫a
    //匿名对象转正之后，编译器认为a是一个有意义的对象了，不会立刻销毁
    NBA a = func2();
    //在此刻销毁的 a
    return 0;
}

五、 二个特殊的构造函数

默认无参构造函数

当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空

默认拷贝构造函数

当类中没有定义拷贝构造函数时，编译器默认提供一个默认拷贝构造函数，简单的进行成员变量的值复制

　注意:

当类中定义了拷⻉贝构造函数时，c++编译器不会提供⽆无参数构造数。
当类中定义了有参数构造函数是,c++编译器不会提供⽆无参数构造函数。
在定义类时,只要你写了构造函数,则必须要⽤用。