c++ Cast MyClass* to int* [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 9 years ago.
Improve this question
I would like to cast a pointer to an instance of MyClass to an int*, preferably in such a way that I can do this:
void function(int*) {...};
MyClass * instance = new MyClass;
function(instance);
The int pointer should NOT be a binary copy of the MyClass pointer. Currently, I am using the following code to acheive a similar result:
int * MyClass::getIntPointer() {return &my_int;}
How do I cast a MyClass* to an int*?

Answer 1

Are you trying to access an int member of your class? If so, you can do this:
class MyClass {
public:
int myInt;
};
void function(int*) {...};
MyClass* instance = new MyClass;
function(&instance->myInt);
You don't want to cast MyClass to an int, you just want to access the member of MyClass.
So here's what that line means:
instance-> // follow the pointer to the actual MyClass object.
instance->myInt // access the int, "myInt"
&instance->myInt // get the address of that int
function(&instance->myInt); // call "function", passing to it the address of "myInt"
EDIT:
If you're creating a class that wraps an int, you can do this with a custom casting operator, as #cmbasnett suggests:
class MyClass {
public:
int* operator int*() { return &my_int; }
private:
int my_int;
};
MyClass instance;
function(instance); // this line will trigger the custom cast operator.

Answer 2

Maybe either of these strike your fancy:
#include <iostream>
struct MyClass
{
int myInt;
operator int*()
{
return &myInt;
}
};
int main()
{
MyClass* instance = new MyClass();
//method 1
instance->myInt = 42;
int* a = &(instance->myInt);
//method 2
int* b = *instance;
std::cout << *a << std::endl;
std::cout << *b << std::endl;
}

Answer 3

Sorry, you're stuck. You cannot overload the typecast operator for a pointer type. This is the only way you could cast from MyClass* directly to int* and require the resulting int* to point at the first int member, even if the class' storage is non-POD.
If you could guarantee that MyClass was always a POD type, then reinterpret_cast<int*>(instance) would be sufficient. But your demand that "The int pointer should NOT be a binary copy of the MyClass pointer" implies that there is no such guarantee.
If you were willing to start with a MyClass& instead of a MyClass*, then you could use cmbasnett's example of adding a typecast overload to the class.