conversion operator question

Hello,Please look at the following code(from C++ in a nutshell) and my
questions.Thanks,***Hunter...
typedef void (*strproc)(const char*);

void print(const char* str)
{
std::cout << "const char*:" << str << '\n';
}

void print(int x)
{
std::cout << "int:" << x << '\n';
}

void print(double x)
{
std::cout << "double:" << x << '\n';
}


struct simple

{
void operator( )(int x) { print(x); } // print(int)
void operator( )(double x) { print(x); } // print(double)
};

typedef void (*intfunc)(int);
typedef void (*dblfunc)(double);

struct indirect
{
operator intfunc( ) { return print; } // print(int)
operator dblfunc( ) { return print; } // print(double)
operator strproc( ) { return print; } // print(const char*)
};



int main( )
{

simple sim;
indirect ind;


sim(42); // Prints "int:42"

sim.operator( )(42); // Prints "int:42"

sim(42.0); // Prints "double:42"//sim(X) is using
overloaded operator ()

ind(42); // Prints "int:42"

ind.operator intfunc( )(42); // Prints "int:42"

ind(42.0); // Prints "double:42"

ind("forty-two"); // Prints "const char*:forty-two"
}Question:The above conversion coperators are used to convert indirect to
intfunc, dblfunc,strproc, how does the above "ind" use coversion operators
to do overloading?and how to decide parameter type?

re: conversion operator question

* hunter hou:[color=blue]
> Hello,Please look at the following code(from C++ in a nutshell) and my
> questions.Thanks,***Hunter...
> typedef void (*strproc)(const char*);
>
> void print(const char* str)
> {
> std::cout << "const char*:" << str << '\n';
> }
>
> void print(int x)
> {
> std::cout << "int:" << x << '\n';
> }
>
> void print(double x)
> {
> std::cout << "double:" << x << '\n';
> }
>
>
> struct simple
>
> {
> void operator( )(int x) { print(x); } // print(int)
> void operator( )(double x) { print(x); } // print(double)
> };
>
> typedef void (*intfunc)(int);
> typedef void (*dblfunc)(double);
>
> struct indirect
> {
> operator intfunc( ) { return print; } // print(int)
> operator dblfunc( ) { return print; } // print(double)
> operator strproc( ) { return print; } // print(const char*)
> };
>
> int main( )
> {
>
> simple sim;
> indirect ind;
>
>
> sim(42); // Prints "int:42"
>
> sim.operator( )(42); // Prints "int:42"
>
> sim(42.0); // Prints "double:42"
> //sim(X) is using overloaded operator ()
>
> ind(42); // Prints "int:42"
>
> ind.operator intfunc( )(42); // Prints "int:42"
>
> ind(42.0); // Prints "double:42"
>
> ind("forty-two"); // Prints "const char*:forty-two"
> }[/color]

Be aware that this code is contrived to illustrate a technical aspect of
the language.

Nobody would write code like that to solve some actual problem.

Most of us (including me) would have to compile it to be sure it's
technically OK.



Question:The above conversion coperators are used to convert indirect to[color=blue]
> intfunc, dblfunc,strproc,[/color]

Yes.
[color=blue]
> how does the above "ind" use coversion operators
> to do overloading?[/color]

One might argue that the conversion operators are overloaded on result
type, which is no-no for ordinary functions. However, conversion
operators are not ordinary functions. They are _special_ member
functions, obeying special rules (other special member functions include
constructors, destructors and assignment operators); special member
functions are discussed in section 12 of the standard, "Special member
functions", and conversion operators in 12.3.2.

[color=blue]
> and how to decide parameter type?[/color]

That's something at least I don't want to think about; the rules for
viable functions and matching are complex, to say the least. However,
usually they produce the intuitive result, as they're designed to. Some
times you get surprised, though, and then the best course is in my
opinion to rewrite the code so that there is no (human-side) ambiguity.




--
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?