能力值：
( LV2，RANK：10 )
2 楼
影响程序的效率通常不在这些小处上，而是在算法的选择上。
能力值：
(RANK：260 )
3 楼
[QUOTE=盛全;539969]实际上 [esp+9C]和 [esp+94] 是unsigned char变量,其值肯定不会大于0xFF
能力值：
(RANK：300 )
4 楼
书呆子果然是专业出生。每次回答都充满的专业气息。
能力值：
( LV9，RANK：170 )
5 楼
汗~ LZ 所贴的例子，本意与不是书呆彭所说的原因eax*2 +99DD90] 中的 eax 值得不到保证。
能力值：
(RANK：260 )
6 楼
[QUOTE=盛全;539969]实际上 [esp+9C]和 [esp+94] 是unsigned char变量,其值肯定不会大于0xFFmovzx eax, byte ptr [esp+9c]
能力值：
( LV2，RANK：10 )
7 楼
谢谢大家的解答。
能力值：
(RANK：260 )
8 楼
[QUOTE=盛全;540273]mov eax, dword ptr [esp+9C]
比
mov al, byte ptr [esp+9C]
高效的话，我想 mov al XXXX是没有存在的意义的。
但事实上mov al XXXX是存在并广泛使用的，而且我N年前我道听途说的听过mov al XXXX 是比 mov ax XXXX 高效的。别人还告诉我如果用char 型可以解决的问题尽量不要用int 。[/QUOTE]
关于代码优化，如果你是在开发某种库，确有其必要，否则不必花太多精力在这上面。
我说的意思，并不是说mov al, xxxx是没有意义的。也不是说谁一定就比谁快。
影响指令执行效率的因素是非常多的，INTEL的不同型号的CPU都不保证同一条指令的内部实现保持不变。
通常情况下，mov eax,xxxx与mov al, xxxx的效率不相上下。但是INTEL的资料中指出，存在一种叫做“部分阻塞”的流水线相关，在这种情况下，使用部分寄存器会降低流水线的效率。
今天我写了一个小程序，你看一下，代码很容易理解：
#include <ctime>
#include <iostream>
#include <iomanip>
#include <windows.h>
LARGE_INTEGER t0,t1;
void PrintTime(void)
{
LARGE_INTEGER tm;
tm.QuadPart = t1.QuadPart-t0.QuadPart;
std::cout << std::hex << std::setfill('0')
<< "\nStart time:\t" << std::setw(8) << t0.HighPart << std::setw(8) << t0.LowPart
<< "\nFinish time:\t" << std::setw(8) << t1.HighPart << std::setw(8) << t1.LowPart
<< "\nCost time:\t" << std::setw(8) << tm.HighPart << std::setw(8) << tm.LowPart
<< std::endl;
}
_declspec(naked) void StartMeassure(void)
{
__asm
{
rdtsc;
mov t0.LowPart, eax;
mov t0.HighPart, edx;
ret
}
}
_declspec(naked) void EndMeassure(void)
{
__asm
{
rdtsc;
mov t1.LowPart, eax;
mov t1.HighPart, edx;
ret
}
}
volatile union
{
unsigned long _dword;
unsigned char _byte[4];
}u0,u1;
int main(void)
{
register unsigned int i;
// 本实验为特殊情况，不具有代表性，只在一定程度上说明问题
// 用不同的指令组合去实现以下功能，测试其执行时间。
// 第一次先用C来描述所执行的功能。
u0._dword = 0x12345678;
std::cout << "Test Starting:" << std::endl;
// 用C描述的版本1，
::StartMeassure();
for ( i = 0; i < 1000000000u; ++i )
{
u1._dword = (unsigned long) u0._byte[0];
}
::EndMeassure();
::PrintTime();
// 用C描述的版本2
::StartMeassure();
for ( i = 0; i < 1000000000u; ++i )
{
u1._dword = 0;
u1._byte[0] = u0._byte[0];
}
::EndMeassure();
::PrintTime();
// 用C描述的版本3，
::StartMeassure();
for ( i = 0; i < 1000000000u; ++i )
{
u1._byte[0] = u0._byte[0];
u1._byte[1] = 0;
u1._byte[2] = 0;
u1._byte[3] = 0;
}
::EndMeassure();
::PrintTime();
// 汇编:使用MOVZX EAX,BYTE PTR XXX
::StartMeassure();
for ( i = 0; i < 1000000000u; ++i )
{
__asm
{
movzx eax, byte ptr u0._byte[0];
mov u1._dword, eax
}
}
::EndMeassure();
::PrintTime();
// 汇编:使用MOV EAX,XXX和AND EAX, 0XFF
::StartMeassure();
for ( i = 0; i < 1000000000u; ++i )
{
__asm
{
mov eax, u0._dword;
and eax, 0xFF
mov u1._dword, eax
}
}
::EndMeassure();
::PrintTime();
// 汇编:使用MOV AL,XXX
::StartMeassure();
__asm xor eax, eax;
for ( i = 0; i < 1000000000u; ++i )
{
__asm
{
mov al, u0._byte[0];
mov u1._dword, eax
}
}
::EndMeassure();
::PrintTime();
::system("PAUSE");
return 0;
}
在我的机器上用VC6的编译器，开了编译器O2优化，输出结果如下：
Test Starting:
Start time: 0001450c6922dcc0
Finish time: 0001450d6d479f10
Cost time: 000000010424c250
Start time: 0001450d6d7c7874
Finish time: 0001450ea15c6c8c
Cost time: 0000000133dff418
Start time: 0001450ea1a701b8
Finish time: 00014510552d83f4
Cost time: 00000001b386823c
Start time: 000145125822a7f4
Finish time: 000145130a8818b0
Cost time: 00000000b26570bc
Start time: 000145130abf634c
Finish time: 00014513be9cf474
Cost time: 00000000b3dd9128
Start time: 00014513bed4f0f4
Finish time: 00014514b4a505d0
Cost time: 00000000f5d014dc
虽然这只能说明一种情况下的执行时间比较，但也能说明某些问题。对编译器不信任，在汇编一级调试，发现循环内部并没有插入多余代码，因此结果具有可比性。
你也可以自己编译运行一下看看结果。
需要说明的是，如果字节地址是在非对齐的地址上，那么使用mov al,xxxx或movzx eax,xxxx的执行效率基本不变，但使用mov eax,xxx / and eax 0xff 访问则效率下降非常大，因为此时需要两个总线周期。
另外我想说几句关于代码优化的事：
绝对不要相信任何经验，只有实验才能说明问题。
经验不仅具有主观性，最主要的是它具有局限性，今天正确的事，明天不一定就正确。
举几个例子：
1.lodsb 指令与 mov al, [esi] / add esi, 4组合哪个执行更快？
2.loop 指令与 dec ecx / jnz 组合哪个执行更快？
3.jecxz指令与 test ecx, ecx/ jz 组合哪个更快？
4. 到达字符串的末尾的以下两段代码
lea esi, [ebp + asciiz] ;6 bytes
s_check: lodsb ;1 byte
test al, al ;2 bytes
jne s_check ;2 bytes
Super's method:
与
lea edi, [ebp + asciiz] ;6 bytes
xor al, al ;2 bytes
s_check: scasb ;1 byte
jne s_check ;2 byte
哪个更快？
对前3个问题，至少经过我的测试，在我的奔腾D上是后者（即两条指令组合）更快，但很多讲优化的书都说前一种快（可能386上确实前者快）。
对于第4个，我没有测试，但是据说后者在386以前的机器上快，前者在486以后的机器上更快。
但是，即便是代码执行效率确实不同，问题是这么优化有什么意义吗？？？这完全是出力不讨好，而且极有可能出错。
我的观点是，没必要在“效率”问题上钻牛角。dzhsurf说得很对，影响效率最主要是算法。所谓“优化”，并不是重点。
我N年前我道听途说的听过mov al XXXX 是比 mov ax XXXX 高效的。
别说N年前，就是上个月，它也不一定是正确的。回到8088/86的时代，8088总线是8位的，当然al比ax快，而且快得多，但8086就已经是16位总线了，它们就没什么差别了。
别人还告诉我如果用char 型可以解决的问题尽量不要用int
不知道是这话是哪里来的。至少我所看到的关于C++的书中，全部都说，“除非是嵌入式领域等
对内存斤斤计较 的场合，否则尽量使用
与机器字宽度相同的 整数类型，而不要为了节约内存使用短的类型”，原因是，”与机器字宽度相同的整数类型更加有利于编译器进行优化“！
写了很多，都只是我个人的经验，所以如果有人指出错误之处，我一定虚心接受。
PS.我的专业恰恰是关于硬件的，所以对流水、相关、总线周期等概念比较熟，倒是对于软件，我属于“非专业”。
能力值：
( LV9，RANK：170 )
9 楼
书呆彭：
你的测试时间方法打印出来不直观，改一改吧，用 QueryPerformanceCounter() 函数，精度和 rdstc 指令差不多：
union {
int i;
char c[4];
} u;
void foo1()
用 byte 复制肯定比 dword 慢
用 movzx eax, byte ptr u.i
mov d, eax
比
mov eax, u.i
and eax,0xff
mov d, eax
慢
能力值：
(RANK：260 )
10 楼
[QUOTE=mik;540327]书呆彭：
能力值：
( LV9，RANK：170 )
11 楼
movzx 与 movsx 是两个相反的操作。
能力值：
( LV9，RANK：170 )
12 楼
对于 movzx eax, byte ptr
对这种取多个字节的指令来说，才有影响。
能力值：
(RANK：260 )
13 楼
我知道movzx和movsx的区别
我的意思是说，在手册里写了，movzx没有对上下文的流水线相关，但movsx就有。
我想表达的意思是说，看上去差不多的指令，对CPU的执行的影响实际是很复杂的。所以不能绝对地说如何如何就会提高效率，如何如何就执行得慢。
对于地址对齐，可能我不会表达，我想说的意思其实和你的意思一样。我在8楼的回复中已经说了：
所以楼主这个问题的结论应该是：
使用movzx eax, byte ptr [esp+9c]是最恰当的。
还是谢谢mik了。
能力值：
( LV9，RANK：170 )
14 楼
按理说，movzx 与 movsx 物理上实现是一样简单的。我看了指令周期也一样呀
能力值：
(RANK：260 )
15 楼
我也没有完全理解，但是手册上第二章的 Assembly/Compier Coding Rule 47 是这么说的，所以我就抄来了。
能力值：
( LV2，RANK：10 )
16 楼
谢谢各位指点。
能力值：
( LV2，RANK：10 )
17 楼
////////////////////////////////
能力值：
( LV9，RANK：170 )
18 楼
不知你看的是哪个版本的 intel optimization 手册
能力值：
(RANK：260 )
19 楼
测试执行时间只是为了对比不同的指令组合的相对 执行时间的差别。可能 会考虑去做这种底层优化。
能力值：
( LV2，RANK：10 )
20 楼
天啊~~加上 and eax ,0xFF 反而变快了！！！这是为什么？？？
能力值：
(RANK：260 )
21 楼
所以我说所谓“优化”，绝对不要相信任何经验，当然更不可想当然。
