16

I'm trying to store the value of an address in a non pointer int variable, when I try to convert it I get the compile error "invalid conversion from 'int*' to 'int'" this is the code I'm using:

#include <cstdlib> #include <iostream> #include <vector> using namespace std; vector<int> test; int main() { int *ip; int pointervalue = 50; int thatvalue = 1; ip = &pointervalue; thatvalue = ip; cout << ip << endl; test.push_back(thatvalue); cout << test[0] << endl; return 0; }
Improve this question
3
  • From the code you have, storing a vector of pointers and printing them would be the same thing. Commented Dec 30, 2012 at 17:17
  • 1
    Why would you do that? The conversion alone is not very portable (and not every environment has uintptr_t), any arithmetic you may want to do with the result is either easier with pointers, or even less portable. Commented Dec 30, 2012 at 17:35
  • If you're converting a pointer value to an integer type, there's a very good chance that you're doing something wrong. It's a legal conversion, if you do it right (and if the machine has some integer type that's big enough to hold the result without loss of information), but 99% of the time you're better off just treating pointers as pointers. If you tell us what you want to do with the pointer value that you think is better done using integers, perhaps we can help you do it without the conversion. Commented Jan 7, 2013 at 16:48

6 Answers 6

Reset to default
31

int may not be large enough to store a pointer.

You should be using intptr_t. This is an integer type that is explicitly large enough to hold any pointer.

 intptr_t thatvalue = 1; // stuff thatvalue = reinterpret_cast<intptr_t>(ip); // Convert it as a bit pattern. // It is valid and converting it back to a pointer is also OK // But if you modify it all bets are off (you need to be very careful).
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

I don't undestand, int isn't large enough to hold any pointer? but int is exactly 4294967295 in size, and thats the equivellent of FFFFFFFF in hex, and aren't pointers just holding the address of a number in memory which is somewhere between 00000000 and FFFFFFFF? Doesn't that mean that int is large enough for a pointer? That was my understanding of how this works, please correct where I am wrong.
@user1934608: Its not guranteed to be big enough. On some systems it will be large enough but not on all systems. For example some 64bit systems will need 64 bits for a pointer yet their integers may only be 32bit (though some will have 64bit integers it all depends). But intptr_t will always be large enough to hold a pointer without loss of information. Note: I use a macbook I changed your code to use a thatvalue = reinterpret_cast<int>(ip) and I get the error: error: cast from ‘int*’ to ‘int’ loses precision
@LokiAstari: It's important to distinguish between int (which is a specific type) and "integers" (which are a collection of types ranging from char to long long int). For example, a system might have a 32-bit int type, and a 64-bit integer type (called long or long long).
8

You can do this:

int a_variable = 0; int* ptr = &a_variable; size_t ptrValue = reinterpret_cast<size_t>(ptr);
Improve this answer

3 Comments

Use std::uintptr_t from <cstdint>.
@GManNickG... thankyou, I wasn't aware of that. I used size_t as its adapts to the pointer size on the platform.
size_t will probably work. But intptr_t is explicitly designed as an integer that can hold a pointer value (without loosing information).
4

Why are you trying to do that, anyway you just need to cast, for C code :

thatvalue = (int)ip;

If your writing C++ code, it is better to use reinterpret_cast

Improve this answer

5 Comments

I'd suggest using C++ style casts like reinterpret_cast instead of old-style C casts.
reinterpret_cast is better than C style cast, the reason : stackoverflow.com/questions/7831696/…
I tried that just now, I think the output it gave was different from the pointer address. it printed: "2293616" and "0x22ff70" all I did was replaced the line thatvalue = ip; with thatvalue = (int)ip;, am I doing something wrong? Edit: nevermind, just googled a hex to base10 converter and figured out where I went wrong.. lol
... this is the same number : 2293616 = 0x22ff70
This is also bound to fail. int may not by large enough to store a pointer especially on 64 bit systems.
4

I'd suggest using reinterpret_cast:

thatvalue = reinterpret_cast<intptr_t>(ip);
Improve this answer

2 Comments

Correct to use reinterpret_cast. But not the int.
I assumed that on OP's machine int was large enough to store a pointer, but I agree with you that in general it's better to use intptr_t e.g. for some 64-bit systems, so I've updated my answer. Thanks.
0

I was able to use the C union statement to achieve what you were looking for. It will of course be compiler dependent, but it worked for me like you would presume it should (Linux, g++).

union { int i; void *p; } mix; mix.p = ip; cout << mix.i << endl;

On my particular instance my int is 32 bit and the pointer is 48 bit. When assigning the pointer, the integer value i will represent the lowest 32 bit of the pointer.

Improve this answer

Comments

0

Since int *ip; is a pointer to an integer and int thatvalue = 1; is an integer, assuming you want the value stored at the address pointed to by ip assigned to thatvalue, change thatvalue = ip; to thatvalue = *ip; (note the addition of the dereference operator * to access a value equivalent to the value at the pointer address).

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.