Why can type conversion operator not be qualified with explicit?

[spamadress]

Hello

I wonder why only constructors can be qualified with explicit to
prevent implicit conversion, but not conversion operators. To me the
following makes perfectly sense:

struct A {
explicit operator int() { return 0;} ;
};
void foo(int) {};
int main() {
A a;
foo( a ); // implicit conversion: should be prohibited by explicit
foo( static_cast<int >(a) ); // explicit conversion: ok
return 0;
}

Greetings

Flo

[Karl Heinz Buchegger]

sp********@bigf oot.com wrote:

Hello

I wonder why only constructors can be qualified with explicit to
prevent implicit conversion, but not conversion operators. To me the
following makes perfectly sense:

struct A {
explicit operator int() { return 0;} ;
};
void foo(int) {};
int main() {
A a;
foo( a ); // implicit conversion: should be prohibited by explicit
foo( static_cast<int >(a) ); // explicit conversion: ok
return 0;
}

Greetings

I can only guess:
Because you could write an ordinary function to do what you want to do?

struct A {
int AsInt() { return 0; }
};

void foo(int) {};
int main()
{ A a;
foo( a ); // implicit conversion: should be prohibited by explicit
foo( a.AsInt() ); // explicit conversion: ok
return 0;
}

--
Karl Heinz Buchegger
kb******@gascad .at

[Victor Bazarov]

sp********@bigf oot.com wrote:

I wonder why only constructors can be qualified with explicit to
prevent implicit conversion, but not conversion operators. To me the
following makes perfectly sense:

struct A {
explicit operator int() { return 0;} ;
};
void foo(int) {};
int main() {
A a;
foo( a ); // implicit conversion: should be prohibited by explicit
foo( static_cast<int >(a) ); // explicit conversion: ok
return 0;
}

IIRC, there is a defect report on that... Lemme see... Nope, can't find
any... But I remember conversations about it. Probably in the newsgroup
archives... Let's go there... Yep. Plenty of discussions. Try this:

http://groups.google.com/groups?q=ty...explicit&hl=en

V

[Julián Albo]

sp********@bigf oot.com wrote:

I wonder why only constructors can be qualified with explicit to
prevent implicit conversion, but not conversion operators. To me the
following makes perfectly sense:

struct A {
explicit operator int() { return 0;} ;
};
void foo(int) {};
int main() {
A a;
foo( a ); // implicit conversion: should be prohibited by explicit
foo( static_cast<int >(a) ); // explicit conversion: ok
return 0;
}

Probaby because is easy and more legible to write a: 'int to_int ();' member
function.

--
Salu2