0

考虑以下代码：

#include "stdio.h"

typedef struct CustomStruct
{
  short Element1[10];
}CustomStruct;

void F2(char* Y)
{
  *Y=0x00;
  Y++; 
  *Y=0x1F;    
}

void F1(CustomStruct* X)
{
  F2((char *)X);
  printf("s = %x\n", (*X).Element1[0]);
}

int main(void)
{
  CustomStruct s;
  F1(&s);

  return 0;
}

在运行时，在调用函数结束时，F1使用不同的编译器会得到不同的结果。

(*X).Element1[0] = 0x1f00在一些编译器和(*X).Element1[0] = 0x001f另一个编译器中。

我很清楚这是一个字节顺序问题。

是否有任何编译器选项或变通方法可供使用，以便(*X).Element1[0] = 0x001f无论使用何种编译器我都能得到？

4

2 回答 2

6

字节顺序不是编译器问题，甚至不是操作系统问题，而是平台问题。字节序没有编译器选项或“解决方法”。然而，有一些转换例程，以便您可以标准化存储数据的字节顺序。

此处记录的ntoh例程会将指向的字节重新排序，从网络顺序（大端）到主机顺序（大或小，取决于主机的类型）。还有一些功能是相反的，从主机顺序到网络顺序。hton

如果要规范化存储在数据结构中的字节，则需要在存储数据或尝试读取数据时自己进行。

以下是我编写的函数模板ntohx，htonx它们概括了数据存储的类型，无论是 2 字节、4 字节还是 8 字节类型：

template<class Val> inline Val ntohx(const Val& in)
{
    char out[sizeof(in)] = {0};
    for( size_t i = 0; i < sizeof(Val); ++i )
        out[i] = ((char*)&in)[sizeof(Val)-i-1];
    return *(reinterpret_cast<Val*>(out));
}

template<> inline unsigned char ntohx<unsigned char>(const unsigned char & v )
{
    return v;
}
template<> inline uint16_t ntohx<uint16_t>(const uint16_t & v)
{
    return ntohs(v);
}

template<> inline uint32_t ntohx<uint32_t>(const uint32_t & v)
{
    return ntohl(v);
}

template<> inline uint64_t ntohx<uint64_t>(const uint64_t & v)
{
    uint32_t ret [] =
    {
        ntohl(((const uint32_t*)&v)[1]),
        ntohl(((const uint32_t*)&v)[0])
    };
    return *((uint64_t*)&ret[0]);
}
template<> inline float ntohx<float>(const float& v)
{
    uint32_t const* cast = reinterpret_cast<uint32_t const*>(&v);
    uint32_t ret = ntohx(*cast);
    return *(reinterpret_cast<float*>(&ret));
};

template<class Val> inline Val htonx(const Val& in)
{
    char out[sizeof(in)] = {0};
    for( size_t i = 0; i < sizeof(Val); ++i )
        out[i] = ((char*)&in)[sizeof(Val)-i-1];
    return *(reinterpret_cast<Val*>(out));
}

template<> inline unsigned char htonx<unsigned char>(const unsigned char & v )
{
    return v;
}
template<> inline uint16_t htonx<uint16_t>(const uint16_t & v)
{
    return htons(v);
}

template<> inline uint32_t htonx<uint32_t>(const uint32_t & v)
{
    return htonl(v);
}

template<> inline uint64_t htonx<uint64_t>(const uint64_t & v)
{
    uint32_t ret [] =
    {
        htonl(((const uint32_t*)&v)[1]),
        htonl(((const uint32_t*)&v)[0])
    };
    return *((uint64_t*)&ret[0]);
}
template<> inline float htonx<float>(const float& v)
{
    uint32_t const* cast = reinterpret_cast<uint32_t const*>(&v);
    uint32_t ret = htonx(*cast);
    return *(reinterpret_cast<float*>(&ret));
};
于 2013-07-03T13:10:43.057 回答
2

如果F2()正在接收 a char *，那么它一定是在做一些非常奇怪的事情才能导致与字节序相关的问题。

这些仅在一次访问多个时才会发生char，除非它在被破坏时手动执行此类访问。是把它的论点转回short *还是什么？

简而言之，显示更多代码。

于 2013-07-03T13:01:21.583 回答