如何将具有两个无符号短整型的结构视为无符号整型？ （在C中）

Question

我创建了一个结构来表示定点正数。我希望小数点两边的数字都由2个字节组成。

typedef struct Fixed_t {
    unsigned short floor; //left side of the decimal point
    unsigned short fraction; //right side of the decimal point
} Fixed;

现在我想添加两个定点数，Fixed x 和 Fixed y。为此，我将它们视为整数并相加。

(Fixed) ( (int)x + (int)y );

但正如我的 Visual Studio 2010 编译器所说，我无法在 Fixed 和 int 之间进行转换。

这样做的正确方法是什么？

编辑：我不致力于固定的 {short Floor, Short Fraction} 实现。

Answer 1

您可以尝试进行令人讨厌的黑客攻击，但这里存在字节序问题。无论您做什么转换，编译器如何知道您希望 floor 成为结果中最重要的部分，而 fraction 成为不太重要的部分？任何依赖于重新解释内存的解决方案都适用于一种字节序，但不适用于另一种字节序。

您应该：

(1) 显式定义转换。假设 short 是 16 位：

unsigned int val = (x.floor << 16) + x.fraction;

(2) 更改 Fixed 使其具有 int 成员而不是两个 Shorts，然后分解需要时，而不是需要时组合。

如果你想让加法更快，那么（2）就是要做的事情。如果您有 64 位类型，那么您也可以进行乘法而不进行分解：unsigned int result = (((uint64_t)x) * y) >> 16. .

顺便说一句，令人讨厌的黑客是这样的：

unsigned int val;
assert(sizeof(Fixed) == sizeof(unsigned int))              // could be a static test
assert(2 * sizeof(unsigned short) == sizeof(unsigned int)) // could be a static test
memcpy(&val, &x, sizeof(unsigned int));

这将在大端系统上工作，其中固定没有填充（并且整数类型没有填充位）。在小端系统上，您需要固定的成员处于其他顺序，这就是它令人讨厌的原因。有时通过 memcpy 进行转换是正确的做法（在这种情况下，这是一个“技巧”而不是“令人讨厌的黑客”）。这只是不是这样的一次。

Answer 2

如果有必要，您可以使用联合，但要注意字节序问题。您可能会发现算术不起作用，而且当然不可移植。

typedef struct Fixed_t {
   union { 
        struct { unsigned short floor; unsigned short fraction }; 
        unsigned int whole;
         };
} Fixed;

（我认为）这更有可能以大端方式工作（Windows/Intel 则不然）。

Answer 3

一些魔法：

typedef union Fixed {
    uint16_t w[2];
    uint32_t d;
} Fixed;
#define Floor w[((Fixed){1}).d==1]
#define Fraction w[((Fixed){1}).d!=1]

要点：

• 我使用固定大小的整数类型，因此您不必依赖于 16 位的 short 和 32 位的 int 。
• Floor 和 Fraction 的宏（大写以避免与 floor() 函数冲突）以独立于字节序的方式访问这两个部分，如下所示foo.Floor 和 foo.Fraction。

编辑：根据OP的要求，对宏的解释：

联合是声明由几种不同的重叠类型组成的对象的一种方式。这里我们有 uint16_t w[2]; 重叠 uint32_t d;，使得可以以 2 个 16 位单元或 1 个 32 位单元的形式访问该值。

(Fixed){1} 是一个复合文字，可以更详细地写为 (Fixed){{1,0}}。它的第一个元素 (uint16_t w[2];) 使用 {1,0} 进行初始化。然后，表达式 ((Fixed){1}).d 的计算结果为 32 位整数，其前 16 位一半为 1，后 16 位一半为 0。系统中，该值为 1，因此 ((Fixed){1}).d==1 计算结果为 1 (true) 并且 ((Fixed){1}).d!= 1 的计算结果为 0（假）。在大端系统上，情况正好相反。

因此，在小端系统上，Floor 为 w[1]，Fraction 为 w[0] 。在大端系统上，Floor 为 w[0]，Fraction 为 w[1]。无论哪种方式，您最终都会存储/访问平台字节序的 32 位值的正确一半。

理论上，假设的系统可以对 16 位和 32 位值使用完全不同的表示形式（例如交错两半的位），从而破坏这些宏。实际上，这不会发生。 :-)

Answer 4

这是不可能移植的，因为编译器不保证 Fixed 将使用与 int 相同的空间量。正确的方法是定义一个函数Fixed add(Fixed a, Fixed b)。

Answer 5

只需单独添加各个部分即可。您需要知道表示“1”的分数的值 - 这里我称之为 FRAC_MAX：

 // c = a + b
 void fixed_add( Fixed* a, Fixed* b, Fixed* c){
     unsigned short carry = 0;
     if((int)(a->floor) + (int)(b->floor) > FRAC_MAX){
         carry = 1;
         c->fraction = a->floor + b->floor - FRAC_MAX; 
     }
     c->floor = a->floor + b->floor + carry;
 }

或者，如果您只是将固定点设置为 2 字节边界，您可以做类似的事情：

void fixed_add( Fixed* a, Fixed *b, Fixed *c){
    int ia = a->floor << 16 + a->fraction;
    int ib = b->floor << 16 + b->fraction;
    int ic = ia + ib;
    c->floor = ic >> 16;
    c->fraction = ic - c->floor;
}

Answer 6

试试这个：

typedef union {
    struct Fixed_t {
        unsigned short floor; //left side of the decimal point
        unsigned short fraction; //right side of the decimal point
    } Fixed;
    int Fixed_int;
}

Answer 7

如果你的编译器将这两个短放在 4 个字节上，那么你可以使用 memcpy 将你的 int 复制到你的结构中，但正如另一个答案中所说，这是不可移植的......而且非常丑陋。

您真的关心在单独的方法中单独添加每个字段吗？
出于性能原因您想保留整数吗？

Answer 8

// add two Fixed 
Fixed operator+( Fixed a, Fixed b ) 
{   
...
}

//add Fixed and int
Fixed operator+( Fixed a, int b ) 
{   
...
}

Answer 9

您可以使用以下方法将任何可寻址类型转换为另一种类型：

*(newtype *)&var