1

传统观点认为，当您bytes一起进行ORing 运算时int，您应该使用|运算符而不是+运算符，否则符号位可能会出现问题。

但在 C# 中似乎并非如此。看起来您可以愉快地使用该+运算符，即使对于负面结果它仍然有效。

我的问题：

  • 这是真的吗？
  • 如果是这样，为什么它会起作用？（为什么很多人认为它不应该——包括我！；）

这是一个测试程序，我相信它使用+运算符和|运算符测试四个字节的每个可能组合，并验证两种方法产生相同的结果。

这是测试代码：

using System;
using System.Diagnostics;

namespace Demo
{
    class Program
    {
        int Convert1(byte b1, byte b2, byte b3, byte b4)
        {
            return b1 + (b2 << 8) + (b3 << 16) + (b4 << 24);
        }

        int Convert2(byte b1, byte b2, byte b3, byte b4)
        {
            return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);
        }

        void Run()
        {
            byte b = 0xff;

            Trace.Assert(Convert1(b, b, b, b) == -1); // Sanity check.
            Trace.Assert(Convert2(b, b, b, b) == -1);

            for (int i = 0; i < 256; ++i)
            {
                Console.WriteLine(i);
                byte b1 = (byte) i;

                for (int j = 0; j < 256; ++j)
                {
                    byte b2 = (byte) j;

                    for (int k = 0; k < 256; ++k)
                    {
                        byte b3 = (byte) k;

                        for (int l = 0; l < 256; ++l)
                        {
                            byte b4 = (byte) l;
                            Trace.Assert(Convert1(b1, b2, b3, b4) == Convert2(b1, b2, b3, b4));
                        }
                    }
                }
            }

            Console.WriteLine("Done.");
        }

        static void Main()
        {
            new Program().Run();
        }
    }
}

[编辑]

要了解它是如何工作的，请考虑以下内容：

byte b = 0xff;

int i1 = b;
int i2 = (b << 8);
int i3 = (b << 16);
int i4 = (b << 24);

Console.WriteLine(i1);
Console.WriteLine(i2);
Console.WriteLine(i3);
Console.WriteLine(i4);

int total = i1 + i2 + i3 + i4;

Console.WriteLine(total);

这打印：

255
65280
16711680
-16777216
-1

啊哈！

4

1 回答 1

2

差异：

  1. 当位重叠时，|会+产生不同的结果：

    2 | 3 = 3
2 + 3 = 5

  2. 实际使用有符号字节时，结果会有所不同：

    -2 | -3   = -1
-2 + (-3) = -5
于 2013-05-16T08:21:30.070 回答