Re: Template functions and avoiding implicit conversions
* tarjei.knapstad@gmail.com:
Consider the following:
class CommandLineOptions
{
public:
template <typename ValueType>
void
Add(std::string& arg, bool required);
template <typename ValueType>
void
Add(std::string& arg, ValueType default);
};
I don't understand why the other replies have not commented on this, but
OK, I'll do it.
First, 'default' is a keyword, you can't use it as a name.
Second, you can't (normally) supply a temporary as actual argument to a
formal argument that's reference to non-const.
It's always a good idea to post /actual code/, the above should not
compile, and so may illustrate some other problem than the one you have.
See the FAQ item titled "How do I post a question about code that
doesn't work correctly?", currently available at <url:
http://www.parashift.com/c++-faq-lite/how-to-post.html#faq-5.8>.
The problem I have is that if I write something like:
CommandLineOptions clo;
clo.Add<std::string>("method", "invert");
the second argument is implicitly converted to bool and the first
template function is instantiated.
I don't understand why the other replies have not commented on this
(also, or would that be "either"?), but OK, I'll do it.
Assuming the above mentioned corrections to the class definition, when
you write what you wrote here you /do not/ get a an implicit conversion
to bool.
#include <iostream>
#include <ostream>
#include <string>
void say( char const s[] ) { std::cout << s << std::endl; }
class CommandLineOptions
{
public:
template <typename ValueType>
void Add( std::string& arg, bool required )
{ say( "bool" ); }
template <typename ValueType>
void Add( std::string const& arg, ValueType const& aDefault )
{ say( "T" ); }
};
int main()
{
CommandLineOptions().Add<std::string>( "method", "invert" );
}
Output: "T".
The possible resolutions I've come up with are:
1. Rename the first function to for instance AddRequired(). I'd like
to avoid this to keep the interface as simple as possible.
2. Require the user to explicitly instantiate a std::string in the
call,
clo.Add<std::string>("method", std::string("invert"));. This is far
too error prone and not really a solution at all.
Is there any other neat trick I could use to avoid the implicit
conversion from happening?
You don't /have/ an implicit conversion (with code that compiles).
And you /would not/ have had one even if you hadn't specified the
template parameter (specifying the template parameter, as in your
example statement, would be a point 3 in the list above).
However, there is an interesting (or perhaps dull to experts in this
area) question of what the 'ValueType const&' formal argument type is
when you supply a string literal. MSVC says it's 'char const [7]'.
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]