Why can't I const_cast the return of the conversion operator?

Question

I've got a conversion operator that returns a const pointer, and I need to const_cast it. However, that doesn't work, at least under MSVC8. The following code reproduces my problem:

class MyClass {
public:
    operator const int* () {
        return 0;
    }
};

int main() {
    MyClass obj;
    int* myPtr;
    // compiles
    const int* myConstPtr = obj;
    // compiles
    myPtr = const_cast<int*>(myConstPtr);
    // doesn't compile (C2440: 'const_cast' : cannot convert from 'MyClass' to 'int *')
    myPtr = const_cast<int*>(obj);
}

Why is that? It seems counter-intuitive. Thanks!

Answer 1

You can only use const_cast to convert to a non-const pointer of the same type (to cast away constness). To cast between unrelated types you need reinterpret_cast.

Answer 2

Probably it would be clearer to your compiler if you do something like:

myPtr = const_cast<int*>(obj());

I haven't tried yet, thought.

EDIT: Shouldn't the operator declaration be something like:

const int* operator () {

Answer 3

Think of const_cast<> as a function template

template <typename Target, typename Source>
Target const_cast( Source src );

(that's not how it's implemented, but it helps here to imagine it was). Then Source is deduced as MyClass, and there's nothing const_cast can do to get an int* from a MyClass.

What you want is either of the following:

const_cast<int*>( static_cast<const int*>(obj) /* invokes operator const int* */ );
// or
const_cast<int*>( obj.operator const int*() );

Answer 4

To make it work you have to do :

myPtr = const_cast<int*>(static_cast<const int*>(obj));

When you const_cast directly, the compiler look for the cast operator to int*.

Answer 5

const_cast can only change the constness of a type. If you want to call the implicit operator you have you need a static_cast and then a const_cast. While it's annoying it makes sure you are explicit in what you are doing.

myPtr = const_cast<int*>(static_cast<const int*>(obj));

You can also use the old school c-style cast operator

myPtr = (int*)(const int*)obj;

But this is highly discouraged for several reasons:

• It isn't grepable
• You can very easily do more than you intended. Most of the time you don't want to mess with const_cast type operations and using static_cast enforces this. In fact you very rarely want a const_cast. If you find yourself doing it regularly you have some design mistakes.

Edit: I was slightly off, I fixed it now. It makes the c-style cast a little uglier