C++类中的构造函数

目录

1.构造函数（普通构造）

构造函数的三种调用方式：

2.拷贝构造

---

在C++中的构造函数分为两类，一个为普通的构造函数，另一种则是拷贝构造。今天我们分别来了解一下这两种构造函数。

1.构造函数（普通构造）

定义：在创建对象时对其进行赋值的一个函数。

作用：主要作用在于创建对象时为对象那个成员属性赋值，构造函数由编译器自动调用，无需手动调用。    

语法：类名（）{}

1.构造函数没有返回值，也不写void

2.函数名称与类名相同

3.构造函数可以有参数，因此可以发生重载

4.程序在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次。

#include<iostream>
using namespace std;
class people {
    string name;
    int money;
public:
    people() {
        name = "";
        money = 0;
        cout << "调用无参构造函数" << endl;
    }
    people(string name, int money) {
        this->name = name;
        this->money = money;
        cout << name << " " << money << endl;
        cout << "调用有参构造函数" << endl;
    }
};
int main() {
    people p1;
    people p2("张三", 100);
    return 0;
}

        在这个函数中写了两个构造函数，一个是无参的构造函数，另外一个是有参的构造函数，这两函数是重载的关系。在主函数中我们创建了一个p1对象，它没有参数，所以它会调用第一个无参的构造函数。而p2则传递了两个参数，所以它会走第二个有参的构造函数。

注意：当没有手写构造函数时，编译器会提供一个默认的无参构造函数，但是里面什么都没有，是空实现。

#include<iostream>
using namespace std;
class people {
public:
    string name;
    int money;   
};
int main() {
    people p1;
    cout << p1.name << " " << p1.money << endl;
    return 0;
}

这段代码也是能正常执行的。

构造函数的三种调用方式：

        括号法：类名 名字(参数) （无参数时：类名 名字；）

        显式法：类名 名字=类名（参数）；

        隐式法：类名 名字={参数}；

#include<iostream>
using namespace std;
class Car {
    string name;
    int money;
public:
    Car() {
        name = "";
        money = 0;
        cout << "调用无参构造函数" << endl;
    }
    Car(string name, int money) {
        this->name = name;
        this->money = money;
        cout << name << " " << money << endl;
        cout << "调用有参构造函数" << endl;
    }
};
int main() {
    //括号法
    Car car1;//无参构造
    Car car2("奔驰",20);//有参构造
    Car car3();//编译器会认为是函数声明 Car函数的返回值 car3是函数名字 （）是函数参数
    Car ("abc",10);//匿名对象，会在当前行结束执行后，系统立刻回收掉匿名对象
    //隐式法
    Car car4 = { "兰博基尼",100 };//explicit 可以禁止构造函数隐式调用

    //显示法
    Car car5 = Car("宝马",30);
    return 0;
}

运行结果如下：

一定要注意的是括号法中无参调用的写法，一定不要加括号，否则会被当成函数声明。

2.拷贝构造

定义：通过当前的对象复制一份一模一样的对象

语法：类名（const 类名&other）{}

调用时机：c++中拷贝构造调用的时机一般有三种

        1.使用一个已经创建完的对象来初始化一个新对象（直接调用构造函数）

        2.值传递的方式给函数参数传值(实参初始化形参)

        3.以值方式返回局部对象

参数或者返回值为引用时，可以避免拷贝构造，如果参数不是引用就会无限递归，递归就是函数自己调用自己,原因如下：

        当函数的参数是对象类型时，如果参数不是引用，在调用函数时，实参会被复制到形参中。这个复制过程会调用拷贝构造函数。而当参数是引用类型时，传递的是对象的引用（可以理解为对象的别名），不会触发拷贝构造函数的调用。

注意：1.不要利用拷贝构造函数初始化匿名对象，编译器会认为是对象声明

#include<iostream>
using namespace std;
class A {
    int num;
public:
    A() {
        num = 0;
        cout << "调用无参构造" << endl;
    }
    A(int a) {
        num = a;
        cout << "调用有参构造" << endl;
    }
    A(const A& other) {//万能引用，避免实参修改形参
        num = other.num;
        cout << "调用拷贝构造" << endl;
    }
};
//使用一个已经创建完的对象来初始化一个新对象
void test1() {
    A a;
    A c(a);
}

//以值的形式传递函数参数时
void test2(A a) {

}

//以值形式返回局部对象时
A test3() {
    A a;
    return a;
}
int main() {
    test1();
    cout << endl;
    A p;
    test2(p);
    cout << endl;
    test3();
    return 0;
}

运行的结果为：
 

在运行的结果中，我们发现test1和test2的确调用了拷贝构造，但是test3似乎没有调用拷贝构造，这是为什么呢？

        实际上，test3也调用了拷贝构造。这里用到了返回值优化，当函数按值返回一个局部对象时，在没有优化的情况下，编译器通常会创建一个临时对象用于存储函数内局部对象的值，然后通过拷贝构造函数将局部对象的值复制到临时对象中。最后，这个临时对象会被用来初始化调用函数处的结果。
        然而，大多数现代编译器都实现了返回值优化（RVO），作者这里用的编译器是vs2022。在test3函数中，编译器直接在main函数中test3调用的地方构造A类型的对象，避免了额外的拷贝构造和临时对象的创建。