我应该在C ++ 11中声明转换运算符吗？

Question

In C++11,it is recommended:

1. to explicitly define our own copy/move constructors, so that the compiler does not do it itself (according to [1] ).
2. to explicitly declare one-argument constructors as explicit, to avoid implicit conversions (according to [2] ).

Should one, in this train of thought, declare conversion operators explicit to prevent the compiler from using them to perform implicit conversions?

Answer 1

The answer is "no, you should not". Explicit conversion operators were added to the language to deal with a specific issue described below. When you are not dealing with that specific issue, you should either add an explicit copy constructor to the destination class, or write a named function instead of the conversion operator (as in c_str() of std::string ).

Let's step back and consider conversion in general. When you need to write a conversion code to go from A to B you have two options - you can define a one-argument constructor, like this

struct B {
    B(const A& a);
};

or you can define a conversion operator, like this:

struct A {
    operator B() const;
};

The first approach has allowed the explicit/implicit control prior to C++11. However, it was not available in two situations:

• You own type A but you do not own type B , or
• You own type A , but type B is primitive

According to the draft paper for the explicit conversion operators of C++11, it is these two cases that the committee was addressing when they argued for adding the explicit conversion operator to the language. All other situations were already covered by (1) implicit and implicit copy constructors, (2) implicit conversion operators, and (3) named member functions.

Answer 2

In C++11,it is recommended:

1. to explicitly define our own copy/move constructors, so that the compiler does not do it itself.

Whoever came up with that recommendation, it is wrong. Whenever the default implementation fits your needs, use it. You'll probably not going to get it better yourself.

2. to explicitly declare one-argument constructors as explicit, to avoid implicit conversions.

The C++ Core Guidelines say "By default, declare single-argument constructors explicit ". You might prefer to have implicit construction in some cases (eg std::string has from const char* ). Leave out the explicit declaration in those cases.

Should one, in this train of thought, declare conversion operators explicit to prevent the compiler from using them to perform implicit conversions?

There is no really good point in making them explicit. That would mean, that the conversion can only be used with a cast. Casts are harder to read than getter function calls. Write conversion operators, when you want implicit conversion, write getters when you want explicit conversion.