C++ Fun with(out) keyword explicit

http://arne-mertz.de/2015/03/fun-without-keyword-explicit/

by ingve • 11 years ago

34 18 11 years ago

arne-mertz.de

mappu• 11 years ago

I wonder which compiler it was?

jsharf• 11 years ago

Me too. I posted a comment on the blog about it, maybe the author will respond there?

sankoz• 11 years ago

Saw a response from the author. The compiler is Embarcadero’s C++ Builder 2010.

blub4• 11 years ago

Embarcadero C++ 2010, formerly known as Borland C++.

cheez• 11 years ago

FWIW, their latest incarnation uses Clang as a front-end for at least the 64-bit version.

dgemm• 11 years ago

Implicit casts are the worst feature of C, and C++ manages to make things even worse with implicit conversions by default. Marvelous.

I should create a new subset of C++ and call it C += 0.5.

oselhn• 11 years ago

In C++11 you can even have implicit conversion for multiple args constructors. But it is harder to use unintentionally than single argument implicit conversions.

echelon• 11 years ago

The choices made by C++ are some of the reasons why I am so happy that Rust exists.

Animats2• 11 years ago

This is why it's a rule in C++ that implicit conversions generate ambiguities and error messages like that. In such ambiguous situations, one interpretation has to be significantly "better" for it to be accepted without an error message. This is better than silently picking one of the possibilities when there's an ambiguity.

I would have thought that the no-conversion case (std::string vs std::string) would clearly beat the conversion case (Annie vs Annie), but I'm not really current on C++ conversion priority.

This sort of thing is why operator overloading isn't that great an idea. It seems attractive at first, but it gets complicated fast. As a rule of thumb, unless you're doing something mathematical, like matrices, for which the rules are well understood, don't overload mathematical operators.

A classic in Python:

   (1,2) + (3,4) -> (1,2,3,4).

But

   numpy.array((1,2)) + numpy.array((3,4)) -> array([4,6]).

This, combined with Python's lack of parameter type checking, can lead to strange results if a library function is called with the wrong type of numerical list object.

blub4• 11 years ago

If one has compile time safety, operator overloading is just fine though.

In this case I'm pretty sure this was a compiler bug, "no conversions" should have priority over "conversions"

dietrichepp3• 11 years ago

Compile-time safety doesn't protect you from being stupid when you choose the semantics of overloaded operators, just like compile-time safety doesn't protect you from giving your functions stupid names. My hypothesis is that so many C++ programmers abused operator overloading (even in the standard library, e.g. the absurdity of <<) that it made language designers remove it altogether from e.g. Java and many other languages.

dietrichepp3• 11 years ago

C++ conversion priority should use the no-conversion case, as the post explains, it was a bad compiler.

srean• 11 years ago

I hear you about abusing overloading, but given how succinct it can make the syntax, I would not want to give it up. Its mix of a pragmatic and philosophical question. Just because some people may abuse it, do you make those suffer who can use it properly. Things get muddy when the set of people who can use it properly is really small. As far as C++ operator overloading is concerned I don't think that is the case. Some enlightened newbies go overboard but most handle it fine enough.

Something about D I like quite a bit is that they lean towards making these confusing things errors rather than have special case rules. C++ is full of complicated special case rules. Just consider template specialization and function overloading. The tie breaking rule is just insane. D community usually prefers making them errors rather blessing one of those ties to be kosher, till the community manages to come up with a compelling easy to remember rule.

72deluxe• 11 years ago

I put the default constructor in private and mark the constructor I want everyone to use (typically the only one) as explicit. Seems safer than implicit conversions.

C++ Fun with(out) keyword explicit

Related Stories