C++11 explicit conversion operators/constructors in return statement

Question

I have a following example (with overly safe boolean type):

#include <cstdlib>

struct boolean_type
{

    explicit
    boolean_type(bool _value)
        : value_(_value)
    { ; }

    explicit
    operator bool () const
    {
        return value_;
    }

private :

    bool value_;

};

struct A
{

    A(int const _i) 
        : i_(_i)
    { ; }

    boolean_type operator == (A const & _other) const
    {
        return (i_ == _other.i_);
    }

private :

    int i_;

};

bool t()
{
    return A(0) == A(0);
}

int main()
{ 
    return EXIT_SUCCESS;
}

It is well-known that such code containing an errors: "could not convert '(((int)((const A*)this)->A::i_) == ((int)other.A::i))' from 'bool' to 'boolean_type'" in return statement of bool A::operator == (A const &) const and "cannot convert 'boolean_type' to 'bool'" in return statement of bool t(). But what the risk here? Why there are not explicit conversion here in both cases? Why are implicit? In fact we explicitly specify the returning type bool in second case and static_assert(std::is_same< bool, decltype(std::declval< int >() == std::declval< int >()) >::value, "!"); as such!

Additionally want to say:

Due to the specified obstruction I cannot simply replace all entries of the bool to my super-safe boolean_type (which is mocked-object) in my user code, because, say, in return statement of boost::variant::operator == uses above construction, that treats there as implicit conversion. Similar obstructions are not unique.

There is no duplicate at all in Q, because there is a consideration of significand details implied in the discussion. — Tomilov Anatoliy
There has been a lot of debate in the committee about this very question (should return imply an explicit conversion to the return type)... — Marc Glisse
@Dukales those I remember were not public conversations. But you could search the wg21 issue lists and the isocpp.org mailing lists. — Marc Glisse
@JohnDibling return is a very special case. You have spelled out the type to convert to a few lines above. This is not the same as converting to some random type that is never mentioned in the function. Then it becomes a matter of taste. I think having to repeat the type in every return statement is a pain. — Marc Glisse

Joseph Mansfield Joseph Mansfield · Accepted Answer · 2014-01-15T17:52:05

You have two implicit conversions. One here:

return (i_ == _other.i_);

And another here:

return A(0) == A(0);

These are implicit because you are not explicitly telling the compiler that you want to convert the result of the comparisons to boolean_type and bool respectively. These implicit conversions are not allowed because you made both the constructor and conversion operator of boolean_type explicit - that's the whole point of the explicit keyword.

You would need to do:

return static_cast<boolean_type>(i_ == _other.i_);

And:

return static_cast<bool>(A(0) == A(0));

The typical reason for making conversions to bool explicit is because the conversion may be used in situations that you did not intend it to be used. For example, if you had boolean_type objects called b1 and b2 with non-explicit conversions, you would be able to do the following:

b1 > 0
b1 == b2

These are probably not the intended uses of the boolean conversion operator.

C++11 explicit conversion operators/constructors in return statement

2 Answers