I saw this code in the book I'm reading, but I'm confused because you can call it withCode:template<class T> string to_string(const T& t) { ostringstream ss; ss << t; return ss.str(); }So why can the template parameters be excluded in this case?Code:to_string(12.34); //instead of to_string<float>(12.34);
Because the compiler can automatically deduce the type of T from the argument you pass.
You only need to explicitly specify types with a class template or if the compiler cannot deduce the type automatically.
Originally Posted by Adak
Note that to_string(12.34); is really to_string<double>(12.34); because 12.34 is a double. If you want to use the float version of the function with 12.34 then you do have to explicitly specify <float> (of course you could also just pass a float: to_string(12.34f)).
Err, that would be bad. It would at least cause a warning of double to float conversion.
No, since the double is a constant, and the compiler should be able to statically prove that no loss of precision occurs. (Unless it does. I don't know if 12.34 is representable.)
All the buzzt!
CornedBee
"There is not now, nor has there ever been, nor will there ever be, any programming language in which it is the least bit difficult to write bad code."
- Flon's Law
Well, even if you put it that way, there is no law that a compiler should do that.
And besides... it's just plain wrong. I was discussed sometime before... using floats with doubles (or the other way around?) can introduce problems, or maybe would.
And even so, passing a double variable into a float template would produce a warning... so I'd say it's better off avoiding it altogether. Do the right thing, so to say.
But how is it passing a float into a double template? If you pass a float, then the template is instantiated as a float template. T would be float, and all would be well.
Well yeah, but not if you explicitly specify the type.
There is no law that it should emit a warning for truncating casts either. Warnings are completely up to the compiler.
No, it's not. Would you want the compiler to emit a warning every time you writeAnd besides... it's just plain wrong.
?Code:short s = 10;
It's exactly the same situation.
All the buzzt!
"There is not now, nor has there ever been, nor will there ever be, any programming language in which it is the least bit difficult to write bad code."
- Flon's Law
even if you can omit the template parameters in such situations i would still say use them it will be helpful to you in the long run in a big project under some complex situation when you are working for 36 hours continuous except those natural breaks in between in short it simply makes the code more clear.
