我决定用一个int tmp变量对简单类型(例如struct或class或仅在其字段中仅使用简单类型的static)的交换函数的实现进行基准测试，以防止每次交换调用中分配内存。所以我写了这个简单的测试程序:

#include <iostream>
#include <chrono>
#include <utility>
#include <vector>


template<typename T>
void mySwap(T& a, T& b)     //Like std::swap - just for tests
{
    T tmp = std::move(a);
    a = std::move(b);
    b = std::move(tmp);
}

template<typename T>
void mySwapStatic(T& a, T& b)   //Here with static tmp
{
    static T tmp;
    tmp = std::move(a);
    a = std::move(b);
    b = std::move(tmp);
}

class Test1 {       //Simple class with some simple types
    int foo;
    float bar;
    char bazz;
};

class Test2 {       //Class with std::vector in it
    int foo;
    float bar;
    char bazz;
    std::vector<int> bizz;
public:
    Test2()
    {
        bizz = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    }
};

#define Test Test1      //choosing class

const static unsigned int NUM_TESTS = 100000000;
static Test a, b;   //making it static to prevent throwing out from code by compiler optimizations

template<typename T, typename F>
auto test(unsigned int numTests, T& a, T& b, const F swapFunction )     //test function
{
    std::chrono::system_clock::time_point t1, t2;
    t1 = std::chrono::system_clock::now();
    for(unsigned int i = 0; i < NUM_TESTS; ++i)    {
        swapFunction(a, b);
    }
    t2 = std::chrono::system_clock::now();
    return std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
}

int main()
{
    std::chrono::system_clock::time_point t1, t2;
    std::cout << "Test 1. MySwap Result:\t\t" << test(NUM_TESTS, a, b, mySwap<Test>) << " nanoseconds\n";   //caling test function
    t1 = std::chrono::system_clock::now();
    for(unsigned int i = 0; i < NUM_TESTS; ++i)    {
        mySwap<Test>(a, b);
    }
    t2 = std::chrono::system_clock::now();
    std::cout << "Test 2. MySwap2 Result:\t\t" << std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count() << " nanoseconds\n"; //This result slightly better then 1. why?!
    std::cout << "Test 3. MySwapStatic Result:\t" << test(NUM_TESTS, a, b, mySwapStatic<Test>) << " nanoseconds\n"; //test function with mySwapStatic
    t1 = std::chrono::system_clock::now();
    for(unsigned int i = 0; i < NUM_TESTS; ++i)    {
        mySwapStatic<Test>(a, b);
    }
    t2 = std::chrono::system_clock::now();
    std::cout << "Test 4. MySwapStatic2 Result:\t" << std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count() << " nanoseconds\n"; //And again - it's better then 3...
    std::cout << "Test 5. std::swap Result:\t" << test(NUM_TESTS, a, b, std::swap<Test>) << " nanoseconds\n";   //calling test function with std::swap for comparsion. Mostly similar to 1...
    return 0;
}

Test 1. MySwap Result: 625,105,480 nanoseconds

Test 2. MySwap2 Result: 528,701,547 nanoseconds

Test 3. MySwapStatic Result: 338,484,180 nanoseconds

Test 4. MySwapStatic2 Result: 228,228,156 nanoseconds

Test 5. std::swap Result: 564,863,184 nanoseconds

最佳答案

首先回答您的第二个问题:在测试2和4中，编译器将内联函数，因此可以提供更好的性能(测试4上还有更多功能，稍后再介绍)。

总体而言，使用静态temp变量可能不是一个好主意。

为什么 ？首先，应该注意的是，在x86汇编中，没有从内存复制到内存的指令。这意味着交换时，CPU寄存器中没有一个，而是两个临时变量。而且这些临时变量必须位于CPU寄存器中，您不能将mem复制到mem，因此静态变量将添加第三个内存位置，以进行来回传输。

静态温度的一个问题是它将阻止内联。想象一下，您交换的变量是否已在CPU寄存器中。在这种情况下，编译器可以内联交换，并且永远不会将任何内容复制到内存中，这要快得多。现在，如果您强制使用静态温度，则编译器将其删除(无用)，或被迫添加内存拷贝。这就是测试4中发生的情况，其中GCC删除了对静态变量的所有读取。它只是毫无意义地向其写入更新的值，因为您已告知这样做。读取的删除说明了良好的性能提升，但可能会更快。

您的测试用例有缺陷，因为它们没有显示这一点。

现在您可能会问:为什么我的静态函数性能更好？我不知道。 (最后答案)

我很好奇，所以我用MSVC编译了您的代码，结果发现MSVC做得正确，而GCC做得很奇怪。在O2优化级别，MSVC会检测到两个交换是无操作的，并且可以将它们快捷化，但是即使在O1，非内联生成的代码也比O3上使用GCC的所有测试用例都快。 (编辑:实际上，MSVC也不正确，请参阅最后的说明。)

MSVC生成的程序集看起来确实更好，但是当比较GCC生成的静态和非静态程序集时，我不知道为什么静态程序的性能更好。

无论如何，我认为即使GCC生成了奇怪的代码，内联问题也应该使用std::swap来解决，因为类型越大，额外的内存拷贝可能会变得代价高昂，而类型越小，内联效果就越好。

这是所有测试用例生成的程序集，如果有人知道为什么GCC静态的性能要比非静态的好，尽管它更长并且使用了更多的内存移动。 编辑:最后回答

GCC非静态(性能570毫秒):

00402F90 44 8B 01             mov         r8d,dword ptr [rcx]
00402F93 F3 0F 10 41 04       movss       xmm0,dword ptr [rcx+4]
00402F98 0F B6 41 08          movzx       eax,byte ptr [rcx+8] 
00402F9C 4C 8B 0A             mov         r9,qword ptr [rdx]
00402F9F 4C 89 09             mov         qword ptr [rcx],r9
00402FA2 44 0F B6 4A 08       movzx       r9d,byte ptr [rdx+8]
00402FA7 44 88 49 08          mov         byte ptr [rcx+8],r9b
00402FAB 44 89 02             mov         dword ptr [rdx],r8d 
00402FAE F3 0F 11 42 04       movss       dword ptr [rdx+4],xmm0
00402FB3 88 42 08             mov         byte ptr [rdx+8],al

00402F10 48 8B 01             mov         rax,qword ptr [rcx]  
00402F13 48 89 05 66 11 00 00 mov         qword ptr [404080h],rax  
00402F1A 0F B6 41 08          movzx       eax,byte ptr [rcx+8]  
00402F1E 88 05 64 11 00 00    mov         byte ptr [404088h],al  
00402F24 48 8B 02             mov         rax,qword ptr [rdx]  
00402F27 48 89 01             mov         qword ptr [rcx],rax  
00402F2A 0F B6 42 08          movzx       eax,byte ptr [rdx+8]  
00402F2E 88 41 08             mov         byte ptr [rcx+8],al  
00402F31 48 8B 05 48 11 00 00 mov         rax,qword ptr [404080h]  
00402F38 48 89 02             mov         qword ptr [rdx],rax  
00402F3B 0F B6 05 46 11 00 00 movzx       eax,byte ptr [404088h]  
00402F42 88 42 08             mov         byte ptr [rdx+8],al  

00000   f2 0f 10 02  movsdx  xmm0, QWORD PTR [rdx]
00004   f2 0f 10 09  movsdx  xmm1, QWORD PTR [rcx]
00008   44 8b 41 08  mov     r8d, DWORD PTR [rcx+8]
0000c   f2 0f 11 01  movsdx  QWORD PTR [rcx], xmm0
00010   8b 42 08     mov     eax, DWORD PTR [rdx+8]
00013   89 41 08     mov     DWORD PTR [rcx+8], eax
00016   f2 0f 11 0a  movsdx  QWORD PTR [rdx], xmm1
0001a   44 89 42 08  mov     DWORD PTR [rdx+8], r8d

00402F90 44 8B 01             mov         r8d,dword ptr [rcx]  
00402F93 F3 0F 10 41 04       movss       xmm0,dword ptr [rcx+4]  
00402F98 0F B6 41 08          movzx       eax,byte ptr [rcx+8]
00402F9C 4C 8B 0A             mov         r9,qword ptr [rdx]
00402F9F 4C 89 09             mov         qword ptr [rcx],r9
00402F9C 44 8B 0A             mov         r9d,dword ptr [rdx]
00402F9F 44 89 09             mov         dword ptr [rcx],r9d
00402FA2 44 8B 4A 04          mov         r9d,dword ptr [rdx+4]
00402FA6 44 89 49 04          mov         dword ptr [rcx+4],r9d
00402FAA 44 0F B6 4A 08       movzx       r9d,byte ptr [rdx+8]  
00402FAF 44 88 49 08          mov         byte ptr [rcx+8],r9b  
00402FB3 44 89 02             mov         dword ptr [rdx],r8d  
00402FB6 F3 0F 11 42 04       movss       dword ptr [rdx+4],xmm0  
00402FBB 88 42 08             mov         byte ptr [rdx+8],al

关于c++ - 对于简单类型C++，使用静态tmp变量重新实现std::swap()，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29364709/