看看这段c#代码:
byte x = 1;
byte y = 2;
byte z = x + y; // ERROR: Cannot implicitly convert type 'int' to 'byte'
在字节(或短)类型上执行的任何数学运算的结果都隐式地转换回整数。解决方案是显式地将结果转换回一个字节:
byte z = (byte)(x + y); // this works
我想知道的是为什么?是建筑吗?哲学吗?
我们有:
Int + Int = Int 长+长=长 浮+浮=浮 Double + Double = Double
所以为什么不呢:
字节+字节=字节 空头+空头=空头?
一点背景知识:我正在对“小数字”(即< 8)执行一个长列表的计算，并将中间结果存储在一个大数组中。使用字节数组(而不是int数组)更快(因为缓存命中)。但是大量的字节强制转换散布在代码中，使得代码更加难以阅读。
当前回答
在添加字节和将结果截断回字节时显示一些低效的答案是不正确的。X86处理器有专门为8位数的整数运算而设计的指令。
事实上，对于x86/64处理器，执行32位或16位操作的效率低于64位或8位操作，因为必须对操作数前缀字节进行解码。在32位机器上，执行16位操作需要同样的代价，但是仍然有专门的8位操作的操作码。
许多RISC架构都有类似的本地字/字节高效指令。那些通常没有存储并转换为某个比特长度的signed值的类型。
换句话说，这个决定必须基于对字节类型用途的感知，而不是由于硬件的底层低效率。
其他回答
C#
ECMA-334指出，只有在int+int、uint+uint、long+long和ulong+ulong (ECMA-334 14.7.4)上，加法才被定义为合法。因此，这些是关于14.4.2需要考虑的候选操作。由于存在从byte到int、uint、long和ulong的隐式强制转换，所有加法函数成员都是14.4.2.1下适用的函数成员。我们必须根据14.4.2.3中的规则找到最佳隐式转换:
将(C1)转换为int(T1)比将(C2)转换为uint(T2)或ulong(T2)更好，因为:
如果T1是int, T2是uint或ulong, C1是更好的转换。
将(C1)转换为int(T1)比将(C2)转换为long(T2)更好，因为从int转换为long存在隐式转换:
如果存在从T1到T2的隐式转换，且不存在从T2到T1的隐式转换，则C1是更好的转换。
因此使用int+int函数，该函数返回int型。
可以说它深埋在c#规范中。
CLI
CLI只对6种类型(int32、native int、int64、F、O和&)起作用。(ECMA-335分区3节1.5)
Byte (int8)不是这些类型之一，在添加之前会自动强制转换为int32。(ECMA-335分区3节1.6)
我已经测试了字节和int之间的性能。 int值:
class Program
{
private int a,b,c,d,e,f;
public Program()
{
a = 1;
b = 2;
c = (a + b);
d = (a - b);
e = (b / a);
f = (c * b);
}
static void Main(string[] args)
{
int max = 10000000;
DateTime start = DateTime.Now;
Program[] tab = new Program[max];
for (int i = 0; i < max; i++)
{
tab[i] = new Program();
}
DateTime stop = DateTime.Now;
Debug.WriteLine(stop.Subtract(start).TotalSeconds);
}
}
使用字节值:
class Program
{
private byte a,b,c,d,e,f;
public Program()
{
a = 1;
b = 2;
c = (byte)(a + b);
d = (byte)(a - b);
e = (byte)(b / a);
f = (byte)(c * b);
}
static void Main(string[] args)
{
int max = 10000000;
DateTime start = DateTime.Now;
Program[] tab = new Program[max];
for (int i = 0; i < max; i++)
{
tab[i] = new Program();
}
DateTime stop = DateTime.Now;
Debug.WriteLine(stop.Subtract(start).TotalSeconds);
}
}
结果如下: 字节:3.57s 157mo, 3.71s 171mo, 3.74s 168mo, CPU ~= 30% int: 4.05s 298mo, 3.92s 278mo, 4.28 294mo with CPU ~= 27% 结论: 字节使用更多的CPU，但它消耗更少的内存，它更快(可能是因为有更少的字节分配)
我记得曾经读过Jon Skeet(现在找不到了，我会继续找)关于字节如何实际上不会重载+操作符的内容。事实上，当像您的示例中那样添加两个字节时，每个字节实际上都被隐式转换为int。其结果显然是一个整型。至于为什么要这样设计，我将等待乔恩·斯基特自己发布:)
编辑:找到了!这里有关于这个话题的很棒的信息。
我想我以前在什么地方见过这个。从这篇文章，旧的新事物:
假设我们生活在一个幻想的世界 对'byte'的操作导致了什么 “字节”。
byte b = 32;
byte c = 240;
int i = b + c; // what is i?
在这个幻想世界里，i的值 应该是16岁!为什么?因为这两个 +操作符的操作数都是 字节，因此“b+c”的和计算为 一个字节，由于 整数溢出。(而且，正如我所指出的 之前，整数溢出是新的 安全攻击向量。)
编辑:Raymond实质上是在捍卫C和c++最初采用的方法。在评论中，他从语言向后兼容的角度为c#采用了相同的方法进行了辩护。
就“为什么会发生这种情况”而言，这是因为正如其他人所说的那样，c#中没有为byte、sbyte、short或ushort的算术定义任何操作符。这个答案是关于为什么没有定义这些操作符。
我相信这主要是为了性能。处理器具有本地操作，可以非常快速地处理32位的算术。可以自动地将结果转换回字节，但如果您不希望发生这种行为，则会导致性能损失。
我认为这在一个带注释的c#标准中提到过。看……
编辑:令人恼火的是，我现在已经查看了带注释的ECMA c# 2规范、带注释的MS c# 3规范和注释的CLI规范，但据我所知，它们都没有提到这一点。我相信我已经看到了上面给出的理由，但如果我知道在哪里，我就被吹了。对不起，参考粉丝们:(
