首页 > 试题广场 >

下列代码输出为（）

[单选题]

下列代码输出为（）

class Test {
    int a;
public:
    Test() : a(0) {cout << "void";}
    explicit Test(int i) : a(i) {cout << "int";}
    Test(short s) : a(s) {cout << "short";}
    Test &operator=(int n) {a = n; cout << "operator=";}
};

int main() {
    int n;
    Test a = n;
}

```
int
```
```
short
```
```
void
```
```
void operator=
```

查看答案及解析

cancer大魔王

explicit构造函数的作用
解析：
explicit构造函数是用来防止隐式转换的。请看下面的代码：

class Test1
{
public:
    Test1(int n)
    {
        num=n;
    }//普通构造函数
private:
    int num;
};
class Test2
{
public:
    explicit Test2(int n)
    {
        num=n;
    }//explicit(显式)构造函数
private:
    int num;
};
int main()
{
    Test1 t1=12;//隐式调用其构造函数,成功
    Test2 t2=12;//编译错误,不能隐式调用其构造函数
    Test2 t2(12);//显式调用成功
    return 0;
}

Test1的构造函数带一个int型的参数，代码23行会隐式转换成调用Test1的这个构造函数。而Test2的构造函数被声明为explicit（显式），这表示不能通过隐式转换来调用这个构造函数，因此代码24行会出现编译错误。
普通构造函数能够被隐式调用。而explicit构造函数只能被显式调用。
所以此处不能调用参数为int的构造函数。我认为此时编译器应该在所有带参构造函数中寻找适合的。因为上述中的n可以被转换为short，所以选择了参数是short的构造函数。如果把参数short改为string，编译器就会报错，因为n转换不为string。所以选B

编辑于 2017-08-25 15:23:08 回复(8)

helloabobo

接受一个参数的构造函数允许使用赋值语句隐式调用来初始化对象; 而explicit构造函数只能被显式调用。

发表于 2018-09-24 22:50:15 回复(1)

八戒哥

构造函数的调用发生在以n为参数创建临时变量期间。由于int参数的构造函数声明为explicit，所以不能够调用这个函数，于是，会调用short参数的构造函数

发表于 2017-08-21 16:56:17 回复(5)

秋天里的屁颠虫

Test a=n有等号这种形式是隐式调用构造函数，而explicit关键字修饰的构造函数只能是显示调用，即要用Test a(n)这种方式，所以这里只能调用最接近的构造函数，int n隐式的转换为short

发表于 2020-01-31 19:57:46 回复(0)

宝宝可乖了

因为要产生一个新对象，不会调用赋值运算符，排除D。explicit表示该构造函数只能显式调用，排除B。有参数，肯定不会调用无参构造函数啦。

发表于 2019-03-12 01:52:13 回复(0)

牛客168090569号

要这么理解,先把n强制转换为Test类型,再赋值,而强制类型转换类似于 Test(int n),这里不能隐式调用,于是编译器找到另一个可以隐式调用的 Test(short),于是编译器操作为 Test(short(n));我是这么理解的,不知道对不对;

发表于 2022-07-01 13:29:43 回复(0)

💮ShawnBeans

Test a=n

调用Test（），里面有a（0），所以调用有参数的构造函数，又因为int的是explicit，所以调用最合适的，所以调用short的构造函数

发表于 2019-03-06 21:49:11 回复(0)

xiaobaicai

为什么不是D呀

发表于 2019-06-07 21:07:28 回复(1)

罗马的猫

使用了未初始化的局部变量“n”，如果将n初始化，得到的结果就是short

发表于 2017-10-28 19:52:14 回复(0)

秒速__五厘米

实际运行为B

发表于 2017-09-04 11:24:15 回复(0)

在走神的王老五很活泼

代码中有三个构造函数；

Test(）：无参构造函数；

explicit Test(int n)：只能显示调用，Test a(n)；

Test(short s)：形参为short类型。

Test a = n；n为int型，应该隐式调用构造函数，但是第一个构造函数Test()无参，所以不能调用；第二个构造函数加了explicit修饰，只能显示调用，此处为隐式调用，因此也不能；第三个函数可以进行隐式调用，但是形参类似是short，所以会进行强制类型转换，将int转换为short调用第三个构造函数，因此最终输出结果是“short”

编辑于 2024-02-23 16:00:18 回复(0)

牛客668640012号

首先要明白Text a=n是初始化，初始化的时候自动调用构造函数，所以不会使用重载=，D错了。

Text a=n也就是等价于Text a(n)，也就是构造函数的隐式转换。正常显式调用应该是Text a=Text（n）

而explicit是显式的意思，也就是防止构造函数的隐式转换。所以不能隐氏调用其构造函数，A错了。

又因为里面传递了参数，所以是调用有参构造，而不是无参构造，C错了。

发表于 2023-10-28 14:15:02 回复(0)

陈让然

在创建对象 a 时，将整型变量 n 隐式转换为短整型，调用了接受一个短整型参数的构造函数 Test(short s)，输出 "short"。

explicit是一个关键字，用于修饰类的构造函数。它的作用是防止编译器进行隐式类型转换，只允许显式调用构造函数来创建对象。

当某个构造函数被声明为explicit时，在使用该构造函数进行对象初始化时，必须使用直接的构造函数调用语法，而不能进行隐式类型转换。这样可以避免一些意外的类型转换，增强代码的可读性和安全性。

下面是一个示例说明explicit的作用：

	
		cppCopy Code
	
class MyClass { int value; public: explicit MyClass(int val) : value(val) {} int getValue() { return value; }
}; int main() { // 隐式类型转换，编译错误 // MyClass obj = 10; // 显式调用构造函数进行对象初始化 MyClass obj(10); int result = obj.getValue(); // result = 10 }