在 C++ 中使用 char 数组作为数学数字

Question

我正在尝试在 C++ 中生成 128 和 256 位整数，并注意到将 char** 转换为 int* 并将 int* 转换为 int （以及向后）可用于将 char 数组转换为整数以及将整数转换为 char 数组。 另外，char* + int 工作得很好。

但是，当我尝试 char* + char* 时，编译器告诉我类型无效。有没有解决方法，或者我必须为操作员编写自己的函数？

例如：

int32_t intValue = 2147483647;
char *charPointer = *( char** ) &intValue;
charPointer += 2147483647;
charPointer += 2;
cout << ( *( int64_t* ) &charPointer )  << endl;

输出：4294967296

基本上，我所做的应该类似于以下内容：

int32_t intValue = 2147483647;

内存中的某处：

[ 05 06 07 08 09 0A 0B 0C ] ( address, in hex )
[ .. .. FF FF FF 7F .. .. ] ( value, in hex )

然后：

char *charPointer = *( char** ) &intValue;

内存中的某处：

[ 58 59 5A 5B 5C 5D 5E 5F ] ( address, in hex )
[ .. .. 07 00 00 00 .. .. ] ( value, in hex )

然后：

charPointer += 2147483647;

我真的不知道这里发生了什么。 看起来它确实做了类似的事情：

[ 05 06 07 08 09 0A 0B 0C ] ( address, in hex )
[ .. .. FF FF FF FE .. .. ] ( value, in hex )

那么：

charPointer += 2;

这里也一样。 像这样的事情：

[ 05 06 07 08 09 0A 0B 0C ] ( address, in hex )
[ .. .. 00 00 00 00 01 .. ] ( value, in hex )

最后我只是打印它就好像它是一个8字节整数：

cout << ( *( int64_t* ) &charPointer )  << endl;

那么，任何人都可以解释为什么它不是添加的指针的值而是添加的值被指向？

Answer 1

这些转换确实存在，但它们并没有按照您的想法进行。将指针转换为整数只是将其视为整数；它没有做任何实际的“数学”。例如，char * s = "abcd"; int i = (int) s; 不会每次都给出相同的结果，因为 s 和 i 都只是字符串开始的内存地址。两者都与字符串的实际内容无关。

类似地，char* + int 只是获取偏移量。写成 char * s = "abcd"; char * t = s + 2; 只是 char * s = "abcd"; 的另一种编写方式char * t = &(s[2]);;即s是'a'的内存位置，t是'c'<的内存位置/code> （s，偏移两个 char 宽度，即两个字节）。除了“指针算术”需要数学来计算字节偏移量并查找内存位置之外，没有进行任何实际的数学运算。

char * + char * 没有意义：将两个内存位置“添加”在一起意味着什么？

编辑：这是您添加到问题中的代码：

int intValue = 5198;
char *charValue = *( char** ) &intValue;
charValue += 100;
cout << ( *( int* ) &charValue )  << endl;

让我稍微扩展一下，这样就更清楚发生了什么：

int intValue = 5198;
int * intPtr = &intValue;
// intPtr is now the address of the memory location containing intValue
char ** charPtrPtr = (char**) intPtr;
// charPtrPtr is now the address of the memory location containing intValue,
// but *pretending* that it's the address of a memory location that in turn
// contains the address of a memory location containing a char.
char *charPtr = *charPtrPtr;
// charPtr (note: you called it "charValue", but I've renamed it for clarity)
// is now intValue, but *pretending* that it's the address of a memory
// location containing a char.
charPtr += 100;
// charPtr is now 100 more than it was. It's still really just an integer,
// pretending to be a memory location. The above statement is equivalent to
// "charPtr = &(charPtr[100]);", that is, it sets charPtr to point 100 bytes
// later than it did before, but since it's not actually pointing to a real
// memory location, that's a poor way to look at it.
char ** charPtrPtr2 = &charPtr;
// charPtrPtr2 is now the address of the memory location containing charPtr.
// Note that it is *not* the same as charPtrPtr; we used charPtrPtr to
// initialize charPtr, but the two memory locations are distinct.
int * intPtr2 = (int *) charPtrPtr2;
// intPtr2 is now the address of the memory location containing charPtr, but
// *pretending* that it's the address of a memory location containing an
// integer.
int intValue2 = *intPtr2;
// intValue2 is now the integer that results from reading out of charPtrPtr2
// as though it were actually pointing to an integer. Which, in a perverse
// way, is actually true: charPtrPtr2 pointed to a memory location that held
// a value that was never *really* a memory location, anyway, just an integer
// masquerading as one. But this will depend on the specific platform,
// because there's no guarantee that an "int" and a pointer are the same
// size -- on some platforms "int" is 32 bits and pointers are 64 bits.
cout << intValue2  << endl;

这有意义吗？