我无法阅读汇编代码，因此我的假设可能完全错误！
这是我的代码：
void reverse(char* str)
{
size_t size = strlen(str) / 2;
char tmp;
for (int i = 0; i < size; ++i)
{
tmp = str[size - i - 1];
str[size - i - 1] = str[size + i];
str[size + i] = tmp;
}
}
这是asm输出：
000000000000073a <reverse>:
73a: 55 push %rbp
73b: 48 89 e5 mov %rsp,%rbp
73e: 48 83 ec 20 sub $0x20,%rsp
742: 48 89 7d e8 mov %rdi,-0x18(%rbp)
746: 48 8b 45 e8 mov -0x18(%rbp),%rax
74a: 48 89 c7 mov %rax,%rdi
74d: e8 9e fe ff ff callq 5f0 <strlen@plt>
752: 48 d1 e8 shr %rax
755: 48 89 45 f8 mov %rax,-0x8(%rbp)
759: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%rbp)
760: eb 72 jmp 7d4 <reverse+0x9a>
762: 8b 45 f4 mov -0xc(%rbp),%eax
765: 48 98 cltq
767: 48 8b 55 f8 mov -0x8(%rbp),%rdx
76b: 48 29 c2 sub %rax,%rdx
76e: 48 89 d0 mov %rdx,%rax
771: 48 8d 50 ff lea -0x1(%rax),%rdx
775: 48 8b 45 e8 mov -0x18(%rbp),%rax
779: 48 01 d0 add %rdx,%rax
77c: 0f b6 00 movzbl (%rax),%eax
77f: 88 45 f3 mov %al,-0xd(%rbp)
782: 8b 45 f4 mov -0xc(%rbp),%eax
785: 48 63 d0 movslq %eax,%rdx
788: 48 8b 45 f8 mov -0x8(%rbp),%rax
78c: 48 01 c2 add %rax,%rdx
78f: 48 8b 45 e8 mov -0x18(%rbp),%rax
793: 48 01 d0 add %rdx,%rax
796: 8b 55 f4 mov -0xc(%rbp),%edx
799: 48 63 d2 movslq %edx,%rdx
79c: 48 8b 4d f8 mov -0x8(%rbp),%rcx
7a0: 48 29 d1 sub %rdx,%rcx
7a3: 48 89 ca mov %rcx,%rdx
7a6: 48 8d 4a ff lea -0x1(%rdx),%rcx
7aa: 48 8b 55 e8 mov -0x18(%rbp),%rdx
7ae: 48 01 ca add %rcx,%rdx
7b1: 0f b6 00 movzbl (%rax),%eax
7b4: 88 02 mov %al,(%rdx)
7b6: 8b 45 f4 mov -0xc(%rbp),%eax
7b9: 48 63 d0 movslq %eax,%rdx
7bc: 48 8b 45 f8 mov -0x8(%rbp),%rax
7c0: 48 01 c2 add %rax,%rdx
7c3: 48 8b 45 e8 mov -0x18(%rbp),%rax
7c7: 48 01 c2 add %rax,%rdx
7ca: 0f b6 45 f3 movzbl -0xd(%rbp),%eax
7ce: 88 02 mov %al,(%rdx)
7d0: 83 45 f4 01 addl $0x1,-0xc(%rbp)
7d4: 8b 45 f4 mov -0xc(%rbp),%eax
7d7: 48 98 cltq
7d9: 48 39 45 f8 cmp %rax,-0x8(%rbp)
7dd: 77 83 ja 762 <reverse+0x28>
7df: 90 nop
7e0: c9 leaveq
7e1: c3 retq
这是另一个版本：
void strrev2(unsigned char *str)
{
int i;
int j;
unsigned char a;
unsigned len = strlen((const char *)str);
for (i = 0, j = len - 1; i < j; i++, j--)
{
a = str[i];
str[i] = str[j];
str[j] = a;
}
}
还有asm：
00000000000007e2 <strrev2>:
7e2: 55 push %rbp
7e3: 48 89 e5 mov %rsp,%rbp
7e6: 48 83 ec 20 sub $0x20,%rsp
7ea: 48 89 7d e8 mov %rdi,-0x18(%rbp)
7ee: 48 8b 45 e8 mov -0x18(%rbp),%rax
7f2: 48 89 c7 mov %rax,%rdi
7f5: e8 f6 fd ff ff callq 5f0 <strlen@plt>
7fa: 89 45 fc mov %eax,-0x4(%rbp)
7fd: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%rbp)
804: 8b 45 fc mov -0x4(%rbp),%eax
807: 83 e8 01 sub $0x1,%eax
80a: 89 45 f8 mov %eax,-0x8(%rbp)
80d: eb 4d jmp 85c <strrev2+0x7a>
80f: 8b 45 f4 mov -0xc(%rbp),%eax
812: 48 63 d0 movslq %eax,%rdx
815: 48 8b 45 e8 mov -0x18(%rbp),%rax
819: 48 01 d0 add %rdx,%rax
81c: 0f b6 00 movzbl (%rax),%eax
81f: 88 45 f3 mov %al,-0xd(%rbp)
822: 8b 45 f8 mov -0x8(%rbp),%eax
825: 48 63 d0 movslq %eax,%rdx
828: 48 8b 45 e8 mov -0x18(%rbp),%rax
82c: 48 01 d0 add %rdx,%rax
82f: 8b 55 f4 mov -0xc(%rbp),%edx
832: 48 63 ca movslq %edx,%rcx
835: 48 8b 55 e8 mov -0x18(%rbp),%rdx
839: 48 01 ca add %rcx,%rdx
83c: 0f b6 00 movzbl (%rax),%eax
83f: 88 02 mov %al,(%rdx)
841: 8b 45 f8 mov -0x8(%rbp),%eax
844: 48 63 d0 movslq %eax,%rdx
847: 48 8b 45 e8 mov -0x18(%rbp),%rax
84b: 48 01 c2 add %rax,%rdx
84e: 0f b6 45 f3 movzbl -0xd(%rbp),%eax
852: 88 02 mov %al,(%rdx)
854: 83 45 f4 01 addl $0x1,-0xc(%rbp)
858: 83 6d f8 01 subl $0x1,-0x8(%rbp)
85c: 8b 45 f4 mov -0xc(%rbp),%eax
85f: 3b 45 f8 cmp -0x8(%rbp),%eax
862: 7c ab jl 80f <strrev2+0x2d>
864: 90 nop
865: c9 leaveq
866: c3 retq
为什么第二个版本的速度更快（我想是这样，因为指令少了），为什么objdump为我的代码产生更多的汇编指令？
我的代码使用较少的内存，但我认为这样做也会更快，因为我只递增一个变量（i），而在使用strlen()时不进行强制转换。
答案 0 :(得分：1)
此处的内容：size - i - 1
这实际上损害了您的性能，因为实际上每个循环迭代都会执行该计算。
您关于使用“较少内存”的假设是错误的。这些变量甚至都没有在两种算法中都没有存储在内存中，而是完全保留在寄存器中。因此，一开始就没有需要消除的内存访问，您的优化所要做的唯一一件事就是引入了其他算法，这现在正在减慢循环速度。
在单个指令中可以处理的最复杂形式的x86 arch是variable[variable + constant]。除此之外，还需要使用多条指令来执行指针算法。
此外，编译器会展开代码，从而正确估计连续最多3次迭代的效果。对于具有i和j的代码，这意味着每3次迭代仅递增一次，并且在两者之间使用恒定偏移量。对于您的代码，这意味着要一遍又一遍地重做地址计算。
答案 1 :(得分：1)
i ++和j ++语句可以转换为一条汇编指令，该指令将寄存器加1。
进行算术索引时，它必须加载size到寄存器，用i减去它，然后写入另一个寄存器。 while循环中有4种这样的操作。
答案 2 :(得分：0)
这两个功能都是不好的。
例如，第一个函数不能用于长度为奇数的字符串。
这是一个演示程序。
#include <stdio.h>
#include <string.h>
void reverse(char* str)
{
size_t size = strlen(str) / 2;
char tmp;
for (int i = 0; i < size; ++i)
{
tmp = str[size - i - 1];
str[size - i - 1] = str[size + i];
str[size + i] = tmp;
}
}
int main(void)
{
char s[] = "123";
reverse( s );
puts( s );
return 0;
}
程序输出为
213
该函数中混合了int和size_t类型，它们可能导致无限循环。
在第二个函数中，错误地使用了unsigned int类型而不是size_t类型，并且再次混合使用了int类型和unsigned int类型。
void strrev2(unsigned char *str)
{
int i;
int j;
unsigned char a;
unsigned len = strlen((const char *)str);
for (i = 0, j = len - 1; i < j; i++, j--)
{
a = str[i];
str[i] = str[j];
str[j] = a;
}
}
所以这两个函数的编写都非常糟糕。
函数应声明为
char * reverse( char * );
因此，比较哪个不良功能更快没有什么意义。：）
我认为这种功能通常是使用汇编程序编写的。
使用C，我将按照以下演示程序中所示的方式编写函数。
#include <stdio.h>
#include <string.h>
char * reverse( char * s )
{
if ( *s )
{
for ( char *p = s, *q = s + strlen( s ); p < --q; ++p )
{
char c = *p;
*p = *q;
*q = c;
}
}
return s;
}
int main(void)
{
char s[] = "123";
puts( reverse( s ) );
return 0;
}
答案 3 :(得分：0)
首先，如果要比较任何内容，则需要确保比较两个行为相同的代码。反正...
为什么Linux版本更快（我认为是这样，因为指令少了）
您不能仅仅计算指令的数量并得出结论，即指令少的指令是最快的。
就像C代码一样，汇编代码中可能会有循环。
例如，一个程序集可能在相同的3条指令上循环100次，而另一块程序（执行相同）可能已将循环展开为（例如）200条指令，而没有任何循环。
因此，即使第二个指令有更多的指令，它也可能会明显更快。
还有很多其他原因，您不能仅仅比较汇编代码来找到最快的代码。在硬件级别上存在一些高级功能，例如分支预测，缓存效果，乱序执行，指令相互依赖关系会影响流水线停顿等。这些事情如何影响特定代码的执行时间只有“特定处理器/系统的专家”才能做到仅通过查看汇编代码来进行判断。如果您不是“高级专家”，那么找到最快的代码段的唯一好方法就是测量执行时间。
答案 4 :(得分：0)
保持简单，并避免任何显式索引：
#include <string.h>
...
void my_strrev (char *str)
{
char *rev = str + strlen(str) - 1;
while (str < rev)
{
char ci = *str, cj = *rev;
*str++ = cj, *rev-- = ci; /* (exchange) */
}
}
指针比较在这里定义明确，因为它们都是相同“数组”（或连续内存区域）中元素的地址。这样会产生紧密的loop，适合指令高速缓存，并且易于理解。另外，我建议您使用-O2进行任何真实的分析。