blocks|key|69333|text|在大多数64位目标上，int仍然是32位，而指针是64位，所以不能工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|69334|http://en.wikipedia.org/wiki/64-bit#64-bit_data_models|offset|length|69335|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1I|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

On most 64-bit targets, int is still 32-bit, while pointer is 64bit, so it won't work.

<a href="http://en.wikipedia.org/wiki/64-bit#64-bit_data_models" rel="nofollow">http://en.wikipedia.org/wiki/64-bit#64-bit_data_models</a>

blocks|key|69370|text|不那不安全。不能保证sizeof(int)+==+sizeof(int*)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|69371|在64位平台上，您几乎可以保证它不是。|69372|至于“十六进制值”..。我不知道你在说什么。如果你是在用十六进制来表示指针.你需要一根绳子。|69373|编辑尝试帮助基于注释的OP：|BOLD|69374|因为电脑不能正常工作。我不知道还能怎么解释。int存储一定数量的位(二进制)，长存储也是如此。十六进制是这些位的文本表示(特别是base16表示)。字符串用于值的文本表示。如果需要指针的十六进制表示，则需要将该指针转换为文本(十六进制)。|69375|下面是一个如何做到这一点的c%2B%2B示例：|69376|test.cpp|69377|#include+<string>
#include+<iostream>
#include+<sstream>

int+main()
{

++++int+*p;+//+declare+a+pointer+to+an+int.+
++++std::ostringstream+oss;+//+create+a+stringstream
++++std::string+s;+//+create+a+string

++++//+this+takes+the+value+of+p+(the+memory+address),+converts+it+to+
++++//+the+hexadecimal+textual+representation,+and+puts+it+in+the+stream
++++oss+<<+std::hex+<<+p;

++++//+Get+a+std::string+from+the+stream
++++s+=+oss.str();

++++//+Display+the+string
++++std::cout+<<+s+<<+std::endl;

}|code-block|syntax|javascript|69378|样本输出：|69379|69380|+roach$+g%2B%2B+-o+test+test.cpp|blockquote|69381|69382|roach$+./test|69383|0x7fff68e07730|69384|值得注意的是，当您想要看到一个数字的base10+(十进制)表示时，也需要同样的东西--您必须将它转换为一个字符串。内存中的所有内容都以二进制形式存储(base2)。|69385|entityMap^0|A|R|0|0|0|0|E|0|M|3|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1F|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1G|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1H|8|@$9|1I|A|1J|B|L]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1N|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1O|8|@]|D|@]|E|$]]|$1|S|3|T|5|U|7|1P|8|@]|D|@]|E|$V|W]]|$1|X|3|Y|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]|$1|10|3|11|5|12|7|1S|8|@]|D|@]|E|$]]|$1|13|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]|$1|14|3|15|5|6|7|1U|8|@]|D|@]|E|$]]|$1|16|3|17|5|6|7|1V|8|@]|D|@]|E|$]]|$1|18|3|19|5|6|7|1W|8|@]|D|@]|E|$]]|$1|1A|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|1B|$]]

No, that's not safe. There's no guarantee <code>sizeof(int) == sizeof(int*)</code> 

On a 64 bit platform you're almost guaranteed that it's not. 

As for the "hexadecimal value" ... I'm not sure what you're talking about. If you're talking about the textual representation of the pointer in hexadecimal ... you'd need a string.

Edit to try and help the OP based on comments:

Because computers don't work in hex. I don't know how else to explain it. An <code>int</code> stores some amount of bits (binary), as does a long. Hexadecimal is a textual representation of those bits (specifically, the base16 representation). strings are used for textual representations of values. If you need a hexadecimal representation of a pointer, you would need to convert that pointer to text (hex). 

Here's a c++ example of how you would do that:

<h1>test.cpp</h1>

<pre><code>#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{

 int *p; // declare a pointer to an int. 
 std::ostringstream oss; // create a stringstream
 std::string s; // create a string

 // this takes the value of p (the memory address), converts it to 
 // the hexadecimal textual representation, and puts it in the stream
 oss &lt;&lt; std::hex &lt;&lt; p;

 // Get a std::string from the stream
 s = oss.str();

 // Display the string
 std::cout &lt;&lt; s &lt;&lt; std::endl;

}
</code></pre>

Sample output:

<blockquote>
 roach$ g++ -o test test.cpp 
 roach$ ./test 
 0x7fff68e07730 
</blockquote>

It's worth noting that the same thing is needed when you want to see the base10 (decimal) representation of a number - you have to convert it to a string. Everything in memory is stored in binary (base2)

blocks|key|1516968|text|您可能想要的是使用std::ostream的地址格式：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1516969|int+x(0);
std::cout+<<+&x+<<+'\n';|code-block|syntax|javascript|1516970|至于产生的字符串的长度，您需要确定相应指针的大小:对于每个使用过的字节，输出将使用两个十六进制数字，因为每个十六进制数字可以表示16个值。所有字节通常都被使用，即使不太可能为所有字节拥有内存，例如当指针的大小为8字节时，就像在64位系统上所发生的那样。这是因为堆栈通常从最大的地址向下增长，而可执行代码则从地址范围的开头开始(如果以任何方式触摸，那么第一页就可能被用来造成分段冲突)。在可执行代码上面有一些数据段，后面跟着堆，还有大量未使用的页面。|1516971|entityMap^0|9|C|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

What you probably want is to use <code>std::ostream</code>'s formatting of addresses:

<pre><code>int x(0);
std::cout &lt;&lt; &amp;x &lt;&lt; '\n';
</code></pre>

As to the length of the produced string, you need to determine the size of the respective pointer: for each used byte the output will use two hex digit because each hex digit can represent 16 values. All bytes are typically used even if it is unlikely that you have memory for all bytes e.g. when the size of pointers is 8 bytes as happens on 64 bit systems. This is because the stacks often grow from the biggest address downwards while the executable code start at the beginning of the address range (well, the very first page may be unused to cause segmentation violations if it is touched in any way). Above the executable code live some data segments, followed by the heap, and lots of unused pages.

blocks|key|1518347|text|有一个问题涉及类似的问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1518348|https://stackoverflow.com/a/2369593/1010666|offset|length|1518349|摘要:不要尝试将指针写入非指针变量.如果需要打印指针值，还有其他解决方案。|1518350|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|17|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

There is question addressing similar topic:

<a href="https://stackoverflow.com/a/2369593/1010666">https://stackoverflow.com/a/2369593/1010666</a>

Summary: do not try to write pointers into non-pointer variable.
If you need to print out the pointer value, there are other solutions.

For example:

<pre><code>int* x = new int;
int y = reinterpret_cast&lt;int&gt;(x);
</code></pre>

<code>y</code> now holds the integer value of the memory address of variable <code>x</code>.
Variable <code>y</code> is of size <code>int</code>. Will that <code>int</code> size always be large enough to store the converted memory address of ANY TYPE being converted to <code>int</code>?

EDIT: 
Or is safer to use <code>long int</code> to avoid a possible loss of data?

EDIT 2: Sorry people, to make this question more understandable the thing I want to find out here is the size of returned HEX value as a number, not size of int nor size of pointer to int but plain hex value. I need to get that value in in human-readable notation. That's why I'm using <code>reinterpret_cast</code> to convert that memory HEX value to DEC value. But to store the value safely I also need to fing out into what kind of variable to it: int, long - what type is big enough?

what's the size of hex value of some memory address converted to int or other type?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

例如：int* x = new int;int y = reinterpret_cast<int>(x);y现在保存变量x的内存地址的整数值。变量y的大小为int。该int大小是否总是足够大以存储转换为int的任何类型的转换内存地址？编辑：还是使用long int来避免数据丢失更安全？编辑2：不好意思，为了让这个问题更...

问转换为int或其他类型的内存地址的十六进制值的大小是多少？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问转换为int或其他类型的内存地址的十六进制值的大小是多少？EN