构造函数的使用与explicit关键字

~May~

#include <iostream>

using namespace std;

// 构造函数的定义：
//                1、构造函数没有返回值类型，不能写，连void都不能写
//                2、构造函数的名字必须与类名相同
//                3、构造函数可以通过不同的参数，来实现重载（Overlord）

// explicit:
//                是用来修饰构造函数的，写在构造函数之前。表示无法通过隐式调用来访问这个构造函数


// 注意事项：
//                1、如果我们没有在一个类中写任何的构造函数，系统会为其添加一个public权限的无参构造函数，可以让我们创建对象
//                2、如果我们给一个类写了构造函数，此时系统不会再提供任何默认的构造函数
// 如果我们为了一个类写了有参的构造函数，一般会同时写无参的构造函数

class Person {
public:
        Person() {
                cout << "Person类的无参构造函数执行了" << endl;
        }
        explicit Person(int age) {
                cout << "Person类的有参构造函数执行了" << endl;
        }
        Person(int age,int score) {
                cout << "Person(int,int)构造函数执行了" << endl;
        }

};

int main() {
        // 构造函数的调用：创建对象的时候调用的
        // 1.显示调用
        Person xiaoming = Person();
        // Person xiaoming = Person(10);
        // Person xiaoming = Person(10, 20);

        // Person xiaoming;//如果使用缩写的方式来调用无参的构造函数，创建对象，不能写小括号，否则系统将会认定为是在定义函数
        // Person xiaoming(10);
        // Person xiaoming(10, 20);

        // 2.隐式调用,不需要我们自己写Person(),直接将所有的参数写道一对大括号中，此时系统会根据大括号中的实参类型与数量去匹配对应的构造函数
        // Person xiaoming = {};
        // Person xiaoming = 10;//大括号中若只有一个参数，可以省略大括号  // 添加了explicit关键字后，无法隐式调用
        // Person xiaoming = { 10,20 };

        // 如果使用new的方式进行创建对象，调用的是无参的构造函数可以不写小括号
        // 使用new的方法，在堆上创建对象，这个过程称为实例化
        // Person* xiaoming = new Person;

        return 0;
}

FishC

你提供的代码片段只是部分内容，下面我将提供一个完整的示例来演示构造函数的使用与 explicit 关键字的作用。

构造函数与 explicit 关键字示例

1. #include <iostream>
   
2. 
   
3. using namespace std;
   
4. 
   
5. class Person {
   
6. public:
   
7.     // 默认构造函数
   
8.     Person() {
   
9.         cout << "Default constructor called" << endl;
   
10.     }
    
11. 
    
12.     // 带参数的构造函数
    
13.     explicit Person(int age) {
    
14.         cout << "Parameterized constructor called with age: " << age << endl;
    
15.     }
    
16. 
    
17.     // 带参数的构造函数 (重载)
    
18.     Person(string name) {
    
19.         cout << "Parameterized constructor called with name: " << name << endl;
    
20.     }
    
21. };
    
22. 
    
23. void testFunction(Person p) {
    
24.     cout << "In testFunction" << endl;
    
25. }
    
26. 
    
27. int main() {
    
28.     // 调用默认构造函数
    
29.     Person p1;
    
30. 
    
31.     // 调用带参数的构造函数
    
32.     Person p2(25);
    
33. 
    
34.     // 调用重载的带参数构造函数
    
35.     Person p3("Alice");
    
36. 
    
37.     // 通过构造函数初始化对象
    
38.     Person p4 = 30; // Error: 因为构造函数是explicit
    
39. 
    
40.     // 正确使用：需要显式调用
    
41.     Person p5 = Person(30);
    
42.    
    
43.     // 使用测试函数
    
44.     testFunction(p5);
    
45. 
    
46.     return 0;
    
47. }

复制代码

解释：

• 默认构造函数：无参数的构造函数。
• 带参数的构造函数：explicit 关键字修饰，表示不能通过隐式转换来调用。
• 重载构造函数：多个带参数的构造函数。
• 在 main 函数中展示了如何正确地使用这些构造函数。
  

希望这能帮助你理解构造函数和 explicit 关键字的使用。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。