问个Int16与Int32区别的问题

Question

int16和int32 是不是变量在-32768到32767范围内用int16速度要比int32快一些，不然int16拿来做什么，这两个就只有范围的区别？   

Answer 1

划分的内存空间不同
Int16 表示 16 位有符号的整数。  
Int32 表示 32 位有符号的整数。  

Answer 2

1.内存大小不一样，int16是用2个字节来存储，int32是用4个字节来存储；
2.由于存储字节有多少，所以能表示的大小也不一样。

Answer 3

int     
    -2,147,483,648   到   2,147,483,647   
    
  int16   
  -32768   到   32767   
    
  int32   
    -2,147,483,648   到   2,147,483,647

Answer 4

我觉得应该有道理，我没深究过，反正我都是用int32

Answer 5

呵呵，你确定吗？是不是在64位的机器上long是最快的啊。明显的存储一个int16只要找到两个字节的空间就可以存下了，怎么会反倒慢了呢？

Answer 6

int16占2字节，int32占4字节。根据需要使用对应的类型是应该的，当然int16的地方都用int32代替也没问题。（除非已有接口提供的是int16参数，那也应该提供int16的变量）速度方面，32位CPU的话，应该是int32最快。

Answer 7

不管数据类型定义如何，它最终是以二进制来表示的，那么到底是二进制位数少的运算，存储会快些呢？还是多的会运算快些？这是不管机器设计成多少位的cpu都必须遵循的。

Answer 8

在一些内存非常吃紧的环境， 例如手机，网络。 int16 就有它不可取代的地方

Answer 9

表示32位有符号的整数。指二进制为16位。
十进制表示值介于 -2,147,483,648 到 +2,147,483,647之间的有符号整数。
System.Int32是一个结构体，定义了一个值类型

Answer 10

int16是16位2进制位来存贮的整数
int32是32位2进制位来存贮的整数

Answer 11

你说错了，64位机，还是int最快，只不过这时的int 是int64了。快慢如何看？看CPU取址的效率和ALU的效率，其中IO是速率瓶颈，32位机上32位长的字节取址是最快的。

Answer 12

in16 <=> short int
int32 <=> long int

Answer 13

在.NET版，对计算机原理一知半解也能混到星星和牌牌...基础真的不那么重要了吗？

Answer 14

int16 在内存中是占两个字节
int32 在内存中是占四个字节

Answer 15

win95是16位的，win98是16和32代码混用兼容的，win2000开始是32位的，所以我想是用来兼容在95/98下用16位模式写的com之类的用的

Answer 16

int16 在内存中是占两个字节 
int32 在内存中是占四个字节

Answer 17

醒醒，醒醒：）Int16占空间小，这是肯定的。
就效率而言，主要考虑两个使用者：1.CPU 2..net fwk
1. x86指令对DWORD寻址快过WORD
2. .net fwk中的BCL大量使用int32,比如数组索引等。如果使用int16来计数，那么int16会被首先类型转换到int32,这样反而慢了。
另：给你抄一段书：
From the book: MCTS Self-Paced Training Kit (Exam 70-536): Microsoft® .NET Framework 2.0—Application Development FoundationChapter 1: "Framework Fundamentals"
Lesson 1: "Using Value Types"Best Practices: Optimizing performance with built-in typesThe runtime optimizes the performance of 32-bit integer types (Int32 and UInt32), so use those types for counters and other frequently accessed integral variables. For floating-point operations, Double is the most efficient type because those operations are optimized by hardware.Also, Table 1-1 in the same section lists recommended uses for each type. Relevant to this discussion:Int16 - Interoperation and other specialized uses 
Int32 - Whole numbers and counters 
Int64 - Large whole numbers 

Answer 18

你不知道long就是int64吗？？--------------------------
所谓32位处理器就是一次只能处理32位，也就是4个字节的数据，而64位处理器一次就能处理64位，即8个字节的数据。如果我们将总长128位的指令分别按照16位、32位、64位为单位进行编辑的话：旧的16位处理器，比如 Intel 80286 CPU需要8个指令，32位的处理器需要4个指令，而64位处理器则只要两个指令，显然，在工作频率相同的情况下，64位处理器的处理速度会比16位、 32位的更快。而且除了运算能力之外，与32位处理器相比，64位处理器的优势还体现在系统对内存的控制上。由于地址使用的是特殊的整数，而64位处理器的一个ALU（算术逻辑运算器）和寄存器可以处理更大的整数，也就是更大的地址。传统32位处理器的寻址空间最大为4GB，使得很多需要大容量内存的数据处理程序在这时都会显得捉襟见肘，形成了运行效率的瓶颈。而64位的处理器在理论上则可以达到1800万个TB，1TB等于1024GB，1GB等于 1024MB，所以64位的处理器能够彻底解决32位计算系统所遇到的瓶颈现象，速度快人一等，对于那些要求多处理器可扩展性、更大的可寻址内存、视频/ 音频/三维处理或较高计算准确性的应用程序而言，AMD 64处理器可提供卓越的性能。
当然64位的CPU要发威强的性能还要有相应的64位软件!而现在的软件都以32位CPU而编程的.所以.现在64位比32位CPU没有多大的性能提高啊! 
64位指的是CPU GPRs（General-Purpose Registers，通用寄存器）的数据宽度为64位，64位指令集就是运行64位数据的指令，也就是说处理器一次可以运行64bit数据 
---------------------------
64位，32位应该说的cpu一次性能处理的最大位数，我就纳闷了，当要处理的数据小于最大位数的时候，竟然会慢！！寄存器在怎么设计也是处理bit，只是32位的能同时处理32个bit，那么对于16位的数据，难道它还要先把16位的变成32位的才能处理不成？如果不是那么是进行16个bit操作快呢？还是32个bit操作快？

Answer 19

另外你说的寻址问题，只是说明64位的比32位的地址能更大，就是说程序能支持处理的内存会更大，同理32位的会比16位的会更大，与数据占了多少个字节毫无关系，占一个byte也要一个地址，在同是32位或者64位或者16位的机器上，存储short与int的寻址的速度是一样的，但存储的时候，16位的只要写入2个字节，32位的药写入4个字节，你说到底会哪个更快？

Answer 20

1. x86指令对DWORD寻址快过WORD 难道存储int32和存储int16的地址长度会不一样？兄弟到底搞清楚楼主问的什么？在同一台机器，int32和int16的寻址速度会不一样？？？你老在比较32位机器和16位机器的差别，人家比较的是int16和int32数据类型的差别，看清楚题目再在这里发表好不好2. .net fwk中的BCL大量使用int32,比如数组索引等。如果使用int16来计数，那么int16会被首先类型转换到int32,这样反而慢了。 
首先你确实这样吗？明显的int32的传输中要用4个byte，int16只要用2个byte。不知道哪个傻逼会用short做数据索引，你能用short做索引不？
int[] is = new int[32];
is[(short)0] = 1;
你会傻到这样写吗？
并且索引根本就不是程序本身需要关心的数据。

Answer 21

对于int32和int16什么时候使用，如果我们知道使用的数据不会大于int16.MaxValue，那么就可以选用，int16，但往往数据的大小范围不在int16的范围内，但很少会大过int32的maxvalue，那么通常就用int32了。
举个列子，对于枚举，其实它就是int数据类型，默认就是int32，但如果你对于枚举的项给与的value没有超过255，那么你完全可以转换成byte来进行存储或者在网络上传递。这样就可以省掉3个byte的多余数据。如果一个对象里有超过10个枚举，这很正常，然后需要通讯的频率是每秒钟1w次，你可以计算下可以省下多少带宽。对于网卡要少出力多少数据。

Answer 22

32位和64位机器的内存地址，是指可以用32位存入地址，还是64位存入地址，当然是64位存入的地址能最大，所以这就是为什么写的一个程序，在32位机器上内存超过2g就会报outofmemory，还在64位机器上用64位操作系统就不会。

Answer 23

那是因为windows内存分区给的应用程序区就2G好不好,想要更大的通过更改os启动参数能改到3G

Answer 24

clr上的操作 ,都讨论到cpu数据线上去了,

Answer 25

另外32位CPU在保护模式下的寻址是能到4G的.当然能寻址是一回事,让不让你读写是另一回事.

Answer 26

所谓32位处理器就是一次只能处理32位，也就是4个字节的数据，而64位处理器一次就能处理64位，即8个字节的数据。如果我们将总长128位的指令分别按照16位、32位、64位为单位进行编辑的话：旧的16位处理器，比如 Intel 80286 CPU需要8个指令，32位的处理器需要4个指令，而64位处理器则只要两个指令，显然，在工作频率相同的情况下，64位处理器的处理速度会比16位、 32位的更快。而且除了运算能力之外，与32位处理器相比，64位处理器的优势还体现在系统对内存的控制上。由于地址使用的是特殊的整数，而64位处理器的一个ALU（算术逻辑运算器）和寄存器可以处理更大的整数，也就是更大的地址。传统32位处理器的寻址空间最大为4GB，使得很多需要大容量内存的数据处理程序在这时都会显得捉襟见肘，形成了运行效率的瓶颈。而64位的处理器在理论上则可以达到1800万个TB，1TB等于1024GB，1GB等于 1024MB，所以64位的处理器能够彻底解决32位计算系统所遇到的瓶颈现象，速度快人一等，对于那些要求多处理器可扩展性、更大的可寻址内存、视频/ 音频/三维处理或较高计算准确性的应用程序而言，AMD 64处理器可提供卓越的性能。 
当然64位的CPU要发威强的性能还要有相应的64位软件!而现在的软件都以32位CPU而编程的.所以.现在64位比32位CPU没有多大的性能提高啊! 
64位指的是CPU GPRs（General-Purpose Registers，通用寄存器）的数据宽度为64位，64位指令集就是运行64位数据的指令，也就是说处理器一次可以运行64bit数据 
Windows Server 2003 包括对启动开关的支持，这样，您便可以调整内存使用和内存地址空间的分配。无论系统的物理内存量是多少，Windows 都使用 4 GB 的虚拟地址空间，其中 2 GB 分配给用户模式进程（例如应用程序），另外 2 GB 分配给内核模式进程（例如操作系统和内核模式驱动程序）。在物理内存等于或大于 1 GB 的系统中，可以使用上述两个启动开关，为应用程序分配较多内存 (3 GB)，为操作系统分配较少内存 (1 GB)。额外的虚拟地址空间有助于减少在 Exchange 信息存储进程的虚拟地址空间中产生的内存碎片数量。知道配置3gb的原理了嘛？？你能配置4gb吗？？？？？

Answer 27

CPU的内存读取是有其最小粒度的.
你的读写了两字节不等于CPU实际只操作了两个字节的数据.
就像你在windows进程堆上新申请了1个字节的内存实际上大多数情况是划了4k给你.

Answer 28

cpu的cache确实一次把一片内存都提上去.但你们讨论的和搂住的问题都没什么关系.谁有.net虚拟机的源代码?虚拟机本来就是模拟了一个cpu,讨论cpu速度还不如讨论虚拟机实现.问题是.net虚拟机不开源.

Answer 29

你这个说的是使用AWE吧AWE (Advanced Windowing Extensions)
针对32bit的Windows。Windows2000上不能利用超过4G的内存，一般是2G的内存保留给进程，2G内存保留给核心的。在Windows2000 Advanced Server上可以分配3G给进程，1G留给核心的。1． 如果机器的内存在4G以下，可以使用Physical Address Extensions（PAE）或者是Address Windowing Extensions（AWE）进行扩展，如果机器内存大于4GB就只能使用AWE进行扩展了。这个应该是操作系统而外控制的东西了。

Answer 30

IL运行时还是编译成机器码执行的嘛...
至于不开源除了M$谁也没办法@_@.也可以参考开源的mono...

Answer 31

int16和int32 是不是变量在-32768到32767范围内用int16速度要比int32快一些，不然int16拿来做什么，这两个就只有范围的区别？  只是小的从大的省内容,速度的话,要看在什么机器上了这个要看CPU的字长了,
32位以及32位以上的机器,处理两个速度是一样的,32位以下的话,那越短,自然越快

Answer 32

int16在32位机上也可以和int32一样快 只要地址对齐只用低位就可以，留下来的高位可以放些不常用的东西

Answer 33

1、对于32位机，CPU的寻址只能是4的倍数，而16bit数据并不严格要求放到4倍地址上（要求在2倍地址上），这样比如一个16bit数据地址在0x2上，CPU读取的时候会在0x0出读取32bit，然后右移16bit再传入寄存器。这样显然比直接读32bit数据慢
2、不了解，不发表意见

Answer 34

呃...我说的是虚拟地址空间的寻址,还没扯到机器上插了多大的条子上去.
我所说的2G的用户空间是指的你前面说的超过2G就outof memory的问题.
可用的空间都用完了当然要出错.
另外awe分配的地址永远是可读写的.不存在禁止访问的问题.而且使用的限制很多.
不能干这个不能干那个用着很不爽.要想突破2G/3G瓶颈使用超大数据量的程序只能升
级到64位+插大条子

Answer 35

我所说的2G的用户空间是指的你前面说的超过2G就outof memory的问题. 
---------
我说outofmemory，是说不做任何设置的情况下，那么即使设置3gb，也只有3gb，因为32位操作系统之支持4gb的内存。即使你的内存有16gb，那也是浪费可用的空间都用完了当然要出错. 
----------------------------
不是空间用完了，而是32位的地址最大就那么大了，你有16gb的内存如果不做任何设置，到2gb还是会爆掉的另外awe分配的地址永远是可读写的.不存在禁止访问的问题.而且使用的限制很多. 
-----------------
所以你说能寻址超过4gb，我说awe，就是说明这个得不偿失了，有点不能干这个不能干那个用着很不爽.要想突破2G/3G瓶颈使用超大数据量的程序只能升 
级到64位+插大条子
-------------------------
呵呵，到目前为止，大部分服务器还是32位的，不也运行的很high？设计程序不能说依赖于机器。如果你在32位的机器上能运行的很happy，那么搬到64位的就更好了。有人说咱俩讨论的问题跑题了。其实不然，这些东西跟存储类型是息息相关的，只有明白了这些，在设计程序选用什么类型的时候，才能做到精益求精。
不能因为有了更强大的硬件，而忽视程序上的严谨和苛刻。记得以前听过一个关于唐骏还是李开复的例子，他和另外一个老外两个人实现同一个功能的东西，结果是在一台硬件配置比较好的机器上跑，其性能不相上下，但换到一台差点的机器，他的程序竟然占了比较大的优势。这个例子我记忆犹新，有前辈做出料榜样，是值得现在我们这些写程序的人学习的。

Answer 36

64位下int可以是32位。long才是和机器字长相等的

Answer 37

受益良多。
那么说，一般情况下，.Net FWK 尽量使用Int32?
我以前还想过，为什么for(int i = 0; i< length; i++)
不写成for(byte i = 0; i< length; i++)

Answer 38

还是存取速度的问题.32位的cpu是以4byte为单位读写内存的.
在结构体起始地址是对齐的前提下,
struct 
{
   int a;
   int b;
};
的成员总体的访问效率是比
struct
{
   short a;
   short b;
};
高的.
当然结构的设计各有取舍,有时候会为了省空间使用占用空间较小的类型.比如
在网络传输或存入文件的时候.现在计算机内存普遍较大,空间基本不成问题.
所以就以效率优先了.

Answer 39

是啊！都是一样的，就是int32是四个字节，而int16是两个字节啊

Answer 40

如果你的CPU是16位的，用16的当然就快了

Answer 41

in16 <=> short int 
int32 <=> long int

Answer 42

呵呵，不是你说了算吧，如果你真的要证明这种结构下前者比后者快，你不妨写个测试程序，然后把结果和测试结果贴上来。我都不知道你这么说到底是以什么方式来体现存储速度，给这样的struct赋值？还是给某个这样的struct的数据连续赋值？
如果是给这样的struct赋值，分配8个字节的速度会比分配4个字节内存的速度快？
如果是给属性赋值，写入4个字节的速度会比写入2个字节的速度快？
如果你认为速度慢在内存寻址上，上面我一再强调了，同一台机器对于不同的类型的数据寻址都是一样的，因为地址都是以32位来表示的，如果是在32位的机器上，不可能是int16地址就是以16位表示。我已经说了，做技术要严谨务实，不要老在费嘴皮子，最有效的办法是写代码测。
就我之前用过的int32和int16，我的结论是16要快，例子就是我需要把1个g的实体类写入到磁盘，当我把int32的数据转换成int16来存储后，速度明显上去了，你可能会说是在访问磁盘，io有瓶颈，但为什么io有瓶颈呢？还不是由于数据的大小导致写入的快慢而导致排队长短？那么对于内存操作，虽然可能排队的影响不会很大，但原理是一样的，数据的大小明显是读写内存速度的重要影响因素。因为寻址速度对于任何数据类型的读写都是一样的。

Answer 43

对于程序的性能的影响，显著的就是在多线程情况下，有太多的lock，不但让原本多线程变成了单线程，还导致额外的锁的处理的开销。
然后就是太多的new 导致频繁的分配内存，这个从链表和队列存入处理的结果就能看的处理，因为链表总是要new一个自己的linknode对象，而队列只要存入数据本身即可。这两者的速度差距是比较明显的。然后分配的内存越大自然就越慢，因为空闲的内存的地址不一定是连续的，可能分配某个对象的空间，需要寻址多次才能找到足够的空间。
这都是在编写高效率程序需要尽可能避免的。引申到这个帖子上就很好说明问题了，int32和int16明显有着占用空间大小的区别。

Answer 44

对于程序的性能的影响，显著的就是在多线程情况下，有太多的lock，不但让原本多线程变成了单线程，还导致额外的锁的处理的开销。
然后就是太多的new 导致频繁的分配内存，这个从链表和队列存入处理的结果就能看的处理，因为链表总是要new一个自己的linknode对象，而队列只要存入数据本身即可。这两者的速度差距是比较明显的。然后分配的内存越大自然就越慢，因为空闲的内存的地址不一定是连续的，可能分配某个对象的地址，需要寻址多次才能找到足够的空间。
这都是在编写高效率程序需要尽可能避免的。引申到这个帖子上就很好说明问题了，int32和int16明显有着占用空间大小的区别。

Answer 45

in16 <=> short int 
int32 <=> long int

Answer 46

in16 <=> short int 
int32 <=> long int

Answer 47

int16和int32的位数不同的。
一个可以表示2的16次方个整数，一个是2的32次方个整数。
一个是64K，一个是4G。
这个是和CPU相关的，通常说的32位机就是指内存空间是4G。这个具体的可以看组成原理之类的书。
好像是这样的。

Answer 48

看了下反汇编
以加法为例
add word ptr 是4个字节代码
add dword ptr只要3个inc word要3个字节
inc dword只要2个

Answer 49

不是.Net用户，来凑个热闹。对于 tmxk2002 所说的 int16, int32 效率相同不认同。简单的例子：
几乎所有的32位编译器在默认情况下都是把结构按照32位对齐的方式来存储的，如果速度没影响的话，为什么不节约一点内存呢？编译器的优化可是非常精确的。拿上面的例子说：
struct 
{ 
  int a; 
  int b; 
}; 
占8个字节
 
struct 
{ 
  short a; 
  short b; 
}; 
占4个字节struct 
{ 
  short a; 
  int b; 
}; 
占8个字节这是编译器从速度考虑对代码所做的优化。对于一般的程序而言，这种优化效果不明显，甚至测试出来都一样。
但是tmxk2002所说的效率与存储相关后那就肯定是所占的空间越小越好了。

Answer 50

假如一个变量范围在-32768到32767我会选择int16，我觉得肯定效率比int32高，如果不是那可以把int16废掉得了

Answer 51

效率要分情况，如果以数字为主的话肯定是int32效率高。如果以占内存（硬盘）空间为主的话，肯定空间越小效率越高。

Answer 52

偶只知道占用内存不同。至于速度， 寄存器 高位 低位不是可以分开用吗？？  还真不知道怎么区分这两字节的速度问题。因为以前听说32位快，好像是基于不同cpu的说法，32位比16位的cpu要快。一次性处理的数据位数翻了一倍嘛。至于整型 16 和32  还真没有研究过。

Answer 53

1. 编译器通常会使结构体强制对齐 对于结构体struct struct_x {
   char a;     // 1 byte
   int b;      // 4 bytes
   short c;    // 2 bytes
   char d;     // 1 byte
} ; 编译器会自动插入一些pad struct struct_x {
   char a;            // 1 byte
   char _pad0[3];     // padding to put 'b' on 4-byte boundary
   int b;            // 4 bytes   short c;          // 2 bytes
   char d;           // 1 byte
   char _pad1[1];    // padding to make sizeof(x_) multiple of 4
} 所以sizeof(struct_x) 的返回值会是 12 bytes.  char _pad0[3] 使 int b 成员 4字节对齐;(这里如果是double b;的话,因为double类型长是8字节的,所以变量b会被编译器强制8 bytes对齐这样就需要插入char_pad0[7] 了);
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/normallife/archive/2009/01/07/3726811.aspx请注意红色的文字，为什么不是朝4byte来对其呢？我猜想这是很分配内存相关的，就是说32位的机器是以4byte为最小单元来组织内存的，这样做的好处是总是4的倍数来分配内存的话，能减少不必要的碎片。当然碎片越少分配就越快了。
这跟是不是int32没有关系，只是int32正好是4个byte罢了。跟内存寻址说32位的话int32的寻址效率就比int16快也没关系。其实内存寻址跟v.net framework都没一点关系了，它又怎么知道这个数据类型是int32还是int16呢？

Answer 54

呵呵，难道你的观点就正确了，要拿出证据来，光说别人的错误而无证据是不行的。也许是我无知，但至少我在说出我的想法来探讨这个问题。呵呵，而你的态度呢？一副好像你很知道的样子，但却就知道说别人无知。
到目前为止，还没有人真正拿出可靠的证据或者测试数据来证明我说的是错误。如果能证明，那是最好不过的事情了。
确实有些东西我不知道，这个世界有谁是全知的？就说刚刚上面的人说，struct总是会去对齐的。这个我确实不曾接触过，但我马上我去查了资料，然后给出我知道的可能解释。这才叫讨论。而这位兄弟呢？
我所说的，都是基于本人测试过的结果，然后自己的一个分析，可能测试的不全面，分析的也不透彻。但总归比人云亦云好，大家说呢。

Answer 55

int     
    -2,147,483,648   到   2,147,483,647    
int16   
  -32768   到   32767
int32   
    -2,147,483,648   到   2,147,483,647       int   =   int32 在C#中：   
  int    <==>   System.Int32   
  short  <==>   System.Int16   
  long   <==>   System.Int64 

Answer 56

哈哈..这个人太可爱了....就让他一直错下去好了..to tmxk2002 :
我只是说一下你的观点不对而已..
如果你认为你的观点正确..那无视我的话
如果你也怀疑你自己的观点..很多资料..可以自己查..我没必要证明给你看..不过你要是给钱..我倒是会花点时间来教教你

Answer 57

1.Int等同于Int32,Int是特定于编程语言的写法. 
2.而Int16,Int32,Int64是特定于CLR公共语言运行时的写法,在.NET的编程规范中推荐使用此种写法,而代替Int. 
3.对于64位程序开发,并不是说写成int或者非Int64就不能执行于64位元的 CPU上,因为我们所写的都是ManagedCode(托管代码),能否运行于64位元CPU上,是依赖于.Net FrameWrok本身,所以如果需要在64位元的CPU上运行托管代码,直接下载相应的.Net Framewrok 64位元版本就可以了.(当然虽然如此,64位平台的程序的开发也依旧充满了许多尚未解决的问题) 

Answer 58

呵呵，我已经做过类似的测试了，不然我也不会在这里说我的这些观点了。持另外观点的人却没有给出让我信服的数据。如果那么容易就承认自己的观点是错误的，那还争论什么呢？更何况这些都是我已经碰到的东西，之前我就写了一个关于数据类型相关的组件。性能比较测试都已经做过了。除非我做错了，嘿嘿 int16读写的速度肯定比int32快。

Answer 59

好了好了,大家喝点水,休息一会儿,用下面的代码做一个测试可知,我的环竟是Windows Xp,VC++2005,生成release:#include <windows.h>
#include <iostream>
using namespace std;int main()
{
const unsigned int N = 65536;
unsigned long t1;
int sum;
__int16  n[N];

t1 = GetTickCount();
for(int j=0;j<N;j++)
{
sum = 0;
for(int i=0;i<N;i++)
{
n[i]=i%128;
sum+=n[i];
}
}
t1 = GetTickCount()-t1;
cout<<"t:"<<t1<<" sum:"<<sum<<endl; return 0;
}在我的机器上执行上述代码的输出是:t:6985 sum:4161536
请按任意键继续. . .运行了多遍,最慢为7016,最快为6985.
同一段代码,把__int16改成__int32后,再编译运行,输出结果为:t:6265 sum:4161536
请按任意键继续. . .运行多遍,最慢为6266,最快为6265.
----------------------------------------
天马行空,找一下C专家编程的相关章节看一下好了.
你说的话好多是有道理的,但就一点,你对CPU的构造好像不太了解.对CPU来说,只有一种数类型,这一点,懂点汇编的人都知道.C/C++对于int的优化是最好的,也就是CPU的位宽与int相当,当然了,必须选用与CPU字长相同的编译器才行.
对于int之外的任何数据类型,都是C/C++编译器加入代码实现的,比如,int16的溢出等,而加入的代码会占用执行时间.因此任何其他类型的执行效率都不会比int要高,但如果优化的好的话,可以与int相同(比如有的C编译器,把int16优化为int32).另还有一点,64位CPU与32位CPU的寻址能力相比,其实与CPU数据线的宽度(位数)无关,应该与地址线的位数有关才对,只不过一般来说 ,64位的CPU的地址线比32位的CPU的地址线宽罢了.

Answer 60

实际上,C#与C++相比,C#隐藏了许多东西的.

Answer 61

不知道你的测试程序是怎么写的,本身CPU的缓存的存在就导致测试很难做;
而在windows这种多任务操作系统下频繁的进程切换也会导致测试计数更难做.
另外磁盘那个根本没可比性.磁盘的存取单位是扇区.要想提高写入/读取速度最
好的办法是以512字节为基本单位设计文件结构进行读/写.我写了段程序来做测
试,这里使用CPU时钟来做计数器而不是windows的计时器.精度应该有所提高不
过肯定没在裸机下跑来的精确(此外还有恼人的CPU缓存):
#include <windows.h>
#include <stdio.h>
inline unsigned __int64 GetCycleCount()
{
__asm RDTSC
}
void main ()
{
int a;
short b;
//读计数器
int cint32 = 0;
int cint16 = 0;
//写计数器
int cwint32 = 0;
int cwint16 = 0;

int i = 0;
for (;i< 10000000;++i)
{
int c32 = 0;
int c16 = 0;
//写测试
//32
unsigned __int64 t = GetCycleCount();
__asm mov a,eax
cwint32 += GetCycleCount() - t;
//16
t = GetCycleCount();
__asm mov b,ax
cwint16 += GetCycleCount() - t;


//读测试
t = GetCycleCount();
__asm mov eax,a
cint32 += GetCycleCount() - t;

t = GetCycleCount();
__asm mov ax,b
cint16 += GetCycleCount() - t;
}
puts ("average time:\nread:");
printf ("int32: %d,int16: %d \nwrite:\n",cint32 /i,cint16 / i);

printf ("int32: %d,int16: %d \n",cwint32 /i,cwint16 / i);
}我的机器是Core2 的E4400运行时尽可能的关了QQ之类的进程.
C:\Users\Canon\Desktop\NCTU6>1
average time:
read:
int32: 77,int16: 78
write:
int32: 78,int16: 70C:\Users\Canon\Desktop\NCTU6>1
average time:
read:
int32: 76,int16: 77
write:
int32: 77,int16: 69C:\Users\Canon\Desktop\NCTU6>1
average time:
read:
int32: 78,int16: 79
write:
int32: 79,int16: 71C:\Users\Canon\Desktop\NCTU6>1
average time:
read:
int32: 77,int16: 78
write:
int32: 78,int16: 70C:\Users\Canon\Desktop\NCTU6>1
average time:
read:
int32: 77,int16: 78
write:
int32: 78,int16: 70
可以看到int32的读速度是肯定比int16快的.而且这里还没有考虑缓存的命中问题.
如果缓存全部都没命中一连串的int32和一连串的int16的读写速度差距更大(对于没
对齐的地址CPU不得不进行多次操作)不要小看那1个时钟周期的差距.在SQLServer之
类要进行大量检索之类的应用中积累下来还是有比较可观的性能提升的.

Answer 62

int    
    -2,147,483,648  到  2,147,483,647  
    
  int16  
  -32768  到  32767  
    
  int32  
    -2,147,483,648  到  2,147,483,647