Autoconversion of types is a handy thing, and easy to miss when you don't have it. This is especially so in languages like C++ that have many static type distinctions, but don't do many of the conversions automatically. C++ has a built-in autoconversion mechanism, but it's too dangerous to use much, and the alternative of manually overloading every operation with type-converting wrappers is too tedious for anything but a few basic types, so in practice C++ is a non-autoconverting language.
That's the standard excuse, anyway. C++ actually does provide quite a lot of autoconversions, but some of them are bizarrely unhelpful. Take the most obvious autoconversion, for example: converting integers to strings. I ran into this one today:
string s;
int n = 40;
s = n;
A naïve (or even not-so-naïve) user might expect this to set s
to "40"
, but it's actually "("
. Assigning a single integer to a string
is treated as assignment of a single character, not the decimal representation of the integer. But this is only for assignment; the constructor doesn't accept integers at all. I can think of some excuses for this (characters are sometimes (e.g. by getc
) represented as int
s; string
should be consistent with other collections; base 10 is arbitrary; conversions between semantically different types shouldn't happen automatically; STL is supposed to provide a solid foundation, not be easy to use), but user expectation is so strong here that I'm still surprised.
I'm also surprised I've never run into this before. I habitually use printf
-like functions for generating strings, but not always, so you'd think I'd encounter this more than once a decade, especially since +=
has the same surprising overloading. Do I really never generate strings from single integers? Is this most obvious of autoconversions really so rare in practice?
This isn't supper surprising to me. In general, C never performs operates on chars, just ints. This is because most machines have integer operations only for one or two word sizes.
ReplyDeleteIn C, the expression 'a'+'b' actually implicitly up-converts the chars to ints before doing the addition.
C++ inherits a lot of this from C, so there you have it.