C++ 将char*转换为int

我目前正试图将一个整数转换成一个字符*，以便通过套接字发送它。在receiving方法中，我在逻辑上尝试再次将char*作为整数处理，但我似乎遗漏了一些东西，因为我无法正确地获得它

#include <iostream>

using namespace std;

int main(int argc, char** argv) {

    int num1 = 42;          // Works
    int num2 = 100;         // Works
    int num3 = 126;         // Works
    int num4 = 517;         // Doesn't seem to work for int > 127

    char p1[sizeof(int)];
    *p1 = num1;
    char p2[sizeof(int)];
    *p2 = num2;
    char p3[sizeof(int)];
    *p3 = num3;
    char p4[sizeof(int)];
    *p4 = num4;

    void* pA = p4;
    void* pB = &num4;

    int result1 = static_cast<int>(*p1);
    int result2 = static_cast<int>(*p2);
    int result3 = static_cast<int>(*p3);
    int result4 = static_cast<int>(*p4);

    int resultV1 = *static_cast<int*>(pA);
    int resultV2 = *reinterpret_cast<int*>(p3);
    unsigned int resultV3 = static_cast<int>(*p4);
    int resultV4 = *static_cast<int*>(pB);              // Works, but I need to convert a char* into an int, not a void* into an int

    cout << "R1:        " << result1 << endl;
    cout << "Expected:  " << num1 << endl << endl;
    cout << "R2:        " << result2 << endl;
    cout << "Expected:  " << num2 << endl << endl;
    cout << "R3:        " << result3 << endl;
    cout << "Expected:  " << num3 << endl << endl;
    cout << "R4:        " << result4 << endl;
    cout << "Expected:  " << num4 << endl << endl;
    cout << "RV1:       " << resultV1 << endl;
    cout << "Expected:  " << num4 << endl << endl;
    cout << "RV2:       " << resultV2 << endl;
    cout << "Expected:  " << num4 << endl << endl;
    cout << "RV3:       " << resultV3 << endl;
    cout << "Expected:  " << num4 << endl << endl;
    cout << "RV4:       " << resultV4 << endl;
    cout << "Expected:  " << num4 << endl << endl;

    getchar();
    return 0;
}

#包括
使用名称空间std；
int main（int argc，字符**argv）{
int num1=42；//有效
int num2=100；//有效
int num3=126；//有效
int num4=517；//对于int>127似乎不起作用
字符p1[sizeof（int）]；
*p1=num1；
字符p2[sizeof（int）]；
*p2=num2；
字符p3[sizeof（int）]；
*p3=num3；
字符p4[sizeof（int）]；
*p4=num4；
void*pA=p4；
void*pB=&num4；
int result1=静态_cast（*p1）；
int result2=静态_cast（*p2）；
int result3=静态投影（*p3）；
int result4=静态施法（*p4）；
int resultV1=*静态投影（pA）；
int resultV2=*重新解释铸型（p3）；
无符号int-resultV3=静态_-cast（*p4）；
int resultV4=*static_cast（pB）；//可以工作，但我需要将char*转换为int，而不是将void*转换为int
很抱歉我的原始语法。没有真正好的完整解释，请稍等，但这是有效的

char p1[sizeof(int)];
*((int *) p1) = num1;
char p2[sizeof(int)];
*((int *) p2) = num2;
char p3[sizeof(int)];
*((int *) p3) = num3;
char p4[sizeof(int)];
*((int *) p4) = num4;

void* pA = p4;
void* pB = &num4;

int result1 = *((int *)p1);
int result2 = *((int *)p2);
int result3 = *((int *)p3);
int result4 = *((int *)p4);

如果你不想使用C风格的指针，也许你可以试试这个

void int2CharArr(int num, char* p1){
    p1[0] = num & 0xFF;
    p1[1] = (num >> 8) & 0xFF;
    p1[2] = (num >> 16) & 0xFF;
    p1[3] = (num >> 24) & 0xFF;
}

int charArr2Int(char* p1){
    return (p1[3] << 24) + (p1[2] << 16) + (p1[1] << 8) + p1[0];
}

void test(){
    int a = 0x12345678;
    char q[sizeof(int)];
    int2CharArr(a, q);
    int b = charArr2Int(q);
    printf("%x , %x , %x , %x\n", *q, *(q+1), *(q+2), *(q+3));
    printf("%x\n", b);
}

void int2charar（int num，char*p1）{
p1[0]=num&0xFF；
p1[1]=（数值>>8）&0xFF；
p1[2]=（数值>>16）&0xFF；
p1[3]=（数值>>24）&0xFF；
}
整数字符2int（字符*p1）{
return（p1[3]您可以这样做：

//to a char*
char *P2 = static_cast<char *>((void*)Tst);
//from a char *
int *S1 = static_cast<int *>((void *)P2);

//到一个字符*
char*P2=静态_-cast（（void*）Tst）；
//从一个字符*
int*S1=静态_铸造（（空心*）P2）；

但是，如果每次发送时都发送相同数量的int，则可能需要考虑发送数据块，例如：
int Data[4] ={42,100,126,517};
char *C1 = static_cast<char*>((void*)Data);
send(socket,C1, sizeof(int[4]),NULL);

struct dataBlock
{
char ID[20];
int R1;
int R2;
int R3;
int R4;
};
...
dataBlock Data = {"test\0", 57,100,127,156};
char *Buff = static_cast<char*>((void*)&Data);
send(socket, Buff, sizeof(dataBlock), 0);

int Data[4]={42100126517}；
char*C1=静态（void*）数据；
send（socket，C1，sizeof（int[4]），NULL）；

并收到：
char*Buff=新字符[16]；
recv（socket，buff，sizeof（int[4]），0）；
int Data=静态施法（（无效）buff）；
int R1=数据[0]；
int R2=数据[1]；
int R3=数据[2]；
int R4=数据[3]

或者，如果发送的是混合数据，但每次传输的格式相同，请使用structs，如下所示：

int Data[4] ={42,100,126,517};
char *C1 = static_cast<char*>((void*)Data);
send(socket,C1, sizeof(int[4]),NULL);

struct dataBlock
{
char ID[20];
int R1;
int R2;
int R3;
int R4;
};
...
dataBlock Data = {"test\0", 57,100,127,156};
char *Buff = static_cast<char*>((void*)&Data);
send(socket, Buff, sizeof(dataBlock), 0);

struct数据块
{
字符ID[20]；
int R1；
int R2；
int R3；
int R4；
};
...
数据块数据={“测试\0”，57100127156}；
char*Buff=静态施法（（void*）和数据）；
发送（套接字，Buff，sizeof（数据块），0）；

然后接收：

char *Buff = new char[sizeof(dataBlock)];
recv(socket, Buff, sizeof(dataBlock),0);
dataBlock * Data = static_cast<dataBlock*>((void*)Buff);

char*Buff=新字符[sizeof（数据块）]；
recv（套接字，Buff，sizeof（数据块），0）；
数据块*数据=静态施法（（void*）Buff）；
您可以使用
std:：stringstream
将
char*
转换为
int
。在大多数系统上，
char
的长度为8位，如果有符号，则只能表示-128到127，如果没有符号，则只能表示0到255。您的
num4
对于一个字符来说太大了，无法表示。您建议如何修复代码？我是mo我们或多或少希望问题是这样的，但是如果我在4个不同的字符中存储一个4字节的int，那应该不是问题，对吗？
*p4=num4；
*p1=num1；
应该是
memcpy（p1，&num1，num1的大小）；
但由于端号问题，这是通过套接字传输整数的一种非常不理想的方法。您应该使用
htonl（）
之类的函数。您可以将
int
的地址传递给
read（）
和
write（）之类的函数
-您不必首先将它们复制到
字符数组或从
字符数组复制它们。谢谢，这确实有效！不过我希望不使用C样式转换，所以我可以使用cdhowie或PaulGriffiths的方法。有一个“C”标记，所以我制作了C解决方案。我认为这不适合cpp，因为它违反了一些cpp规则。