首页 > 试题广场 >

In C++, what does "explicit" m

[不定项选择题]

In C++, what does "explicit" mean? what does "protected" mean?

explicit-keyword enforces only explicit casts to be valid

Protected members are accessible in the class that defines them and in classes that inherit from that class.

Protected members only accessible within the class defining them.

```
All the above are wrong
```

查看正确选项

Shining_Rayley

普通构造函数能够被隐式调用。而explicit 构造函数只能被显式调用

发表于 2015-04-22 14:03:29 回复(2)

努力去BAT的女子

A.explicit关键字强制仅有显式调用有效，正确，C++提供关键字explicit，用于阻止不应该允许的经过转换构造函数进行的隐式转换的发生。声明为explicit的构造函数不能在隐式转换中使用。

B.保护成员可以在定义它的类中使用，也可以在派生类中使用，正确。保护类就是为了继承产生的

C.保护成员仅可以在定义它的类中使用。错误，见B

发表于 2015-07-29 20:30:58 回复(3)

天佑lyp

无论什么样方式的继承，有两点不会变。1 父类的private成员被隐藏，不可访问 2 子类成员依然可以访问到父类public/protected成员

也有两点是不相同的，1 父类成员在子类的属性 2 1又决定是否内被子类对象访问。

发表于 2017-08-04 19:43:36 回复(1)

陈让然

在C++中，“显式”是什么意思？“受保护”是什么意思？

A explicit-keyword仅强制显式强制转换有效

B 受保护成员可在定义它们的类中和从该类继承的类中访问。

C 受保护的成员只能在定义它们的类中访问。

D 以上都是错的

在C++中，“显式”（explicit）是一种关键字，用于修饰单参数构造函数，表示该构造函数不能用于隐式类型转换。

例如，考虑以下代码：

class MyClass {
public:
    explicit MyClass(int x) {
        // 构造函数代码
    }
};

void func(MyClass obj) {
    // 函数体
}

int main() {
    MyClass obj1(5);  // 正确，显式调用构造函数
    MyClass obj2 = 10;  // 错误，不能进行隐式类型转换
    func(15);  // 错误，不能进行隐式类型转换
    return 0;
}

在上述代码中，通过使用`explicit`关键字修饰构造函数`MyClass(int x)`，我们禁止了对该构造函数的隐式调用。因此，`MyClass obj2 = 10;`和`func(15);`都会导致编译错误。

另一方面，“受保护”（protected）是一种访问修饰符，用于类的成员。被`protected`修饰的成员可以在派生类中访问，但在类的外部是不可访问的。

例如，考虑以下代码：

class MyBaseClass {
protected:
    int protectedVar;
};

class MyDerivedClass : public MyBaseClass {
public:
    void func() {
        protectedVar = 10;  // 正确，派生类中可以访问受保护的成员
    }
};

int main() {
    MyBaseClass obj;
    obj.protectedVar = 5;  // 错误，受保护的成员在类的外部不可访问
    return 0;
}

在上述代码中，`protectedVar`被声明为受保护的成员变量。因此，在`MyDerivedClass`中的`func()`函数中可以访问`protectedVar`，但在`main()`函数中无法直接访问`obj.protectedVar`，因为它在类的外部。

发表于 2023-09-16 18:16:50 回复(1)

牛客303601720号

全英文是个什么鬼，出bug了啊？

发表于 2022-07-21 19:13:14 回复(1)

haru

有个疑问，B中如果是private继承的话，就不成立了呀

发表于 2016-07-15 09:15:43 回复(6)

说又不是不能用的小鲸鱼很奔放

在C++中，`protected`关键字用于类的成员访问控制，它的作用如下： 1. 在类定义中，`protected`关键字用于声明类的成员（变量和函数）的保护访问级别。被声明为`protected`的成员可以在类的内部和派生类中进行访问，但在类外部是不可访问的。 1. `protected`成员对于类的派生类是可见的，因此派生类可以继承和访问基类中的`protected`成员。 1. `protected`成员提供了一种在类的继承层次结构中实现数据隐藏和封装的方式。它允许派生类访问基类的成员，但限制了对外部的访问。下面是一个示例，演示了`protected`关键字的使用： ```cpp class Base { protected: int protectedVar; public: void SetProtectedVar(int value) { protectedVar = value; } }; class Derived : public Base { public: void AccessProtectedVar() { protectedVar = 10; // 可以在派生类中直接访问基类的protected成员 } }; int main() { Base baseObj; baseObj.protectedVar = 20; // 错误，protected成员在类外部不可访问 Derived derivedObj; derivedObj.protectedVar = 30; // 错误，protected成员在类外部不可访问 derivedObj.SetProtectedVar(30); // 可以通过公有成员函数间接修改protected成员 return 0; } ``` 在上述示例中，`Base`类中的`protectedVar`成员被声明为`protected`，因此在类外部无法直接访问。但是，`Derived`类作为`Base`类的派生类，可以直接访问和修改`Base`类中的`protectedVar`成员。是的，C++中的构造函数可以使用`explicit`关键字进行修饰。当构造函数被声明为`explicit`时，它只能被显式调用，不能隐式调用。隐式调用是指在某些上下文中，编译器会自动将参数类型转换为构造函数所需的类型，然后隐式调用构造函数。这种隐式转换在某些情况下可能会导致意外的行为或歧义，因此通过将构造函数声明为`explicit`来禁止隐式调用，可以提高代码的清晰性和安全性。以下是一个示例说明： ```cpp class MyClass { public: // 隐式调用构造函数 MyClass(int value) { // 构造函数的实现 } }; class YourClass { public: // 显式调用构造函数 explicit YourClass(int value) { // 构造函数的实现 } }; void DoSomething(MyClass obj) { // 执行某些操作 } void DoSomethingElse(YourClass obj) { // 执行某些其他操作 } int main() { MyClass myObj = 10; // 隐式调用构造函数 YourClass yourObj = 20; // 编译错误，不能隐式调用构造函数 DoSomething(30); // 隐式调用构造函数 DoSomethingElse(40); // 编译错误，不能隐式调用构造函数 return 0; } ``` 在上面的示例中，`MyClass`的构造函数可以隐式调用，因此可以通过简单的赋值语句或作为函数参数进行隐式构造。而`YourClass`的构造函数被声明为`explicit`，因此不能隐式调用，只能通过显式的方式来构造对象。请注意，`explicit`关键字只能用于单参数构造函数，因为多参数构造函数不会导致隐式转换。

编辑于 2023-08-12 19:21:32 回复(0)