提高c++性能的编程技术 pdf_《提高C++性能的编程技术》笔记-第11章

11.标准模板库

1. 标准模板库（STL）是容器和通用算法的强效结合。但是从性能的角度出发，我们要考虑以下问题：

(1). 在渐近复杂度方面，STL与各种容器和算法的性能密切相关。这是什么意思？

(2). STL是由很多容器组成的，对于一个具体的计算任务（例如排序、插入、删除、遍历、查找等），应该使用哪种容器比较好，为什么？另外，在特定的条件下还有更好的选择吗？

(3). STL的性能如何？如果更好的使用自定义的容器和算法？

2. 插入测试

案例：

#include <iostream>
#include <stdlib.h>
#include <windows.h>
#include <algorithm>
#include <vector>
#include <list>
#include <set>

static LARGE_INTEGER cpuFreq;
static LARGE_INTEGER startTime;
static LARGE_INTEGER endTime;
static double run_time = 0.0;

using namespace std;

/*目的：测试不同容器，插入数据的性能*/
/*测试要求：将100万个随机元素插入到数组、向量、列表和多重集中。每个插入测试带有三个参数
     1.指向被测目标容器的指针。
     2.指向data数组的指针，该数组保存了要插入到目标容器的元素。
     3.data数组的大小。
*/

//数组形式插入
template <class T>
void arrayInsert(T *a, const T *collection, int size)
{
    for(int k = 0; k < size; k++){
        a[k] = collection[k];
    }
}

//向量形式插入
template <class T>
void vectorInsert(vector<T> *v, const T *collection, int size)
{
    for(int k = 0; k < size; k++){
       v->push_back(collection[k]);
    }
}

//向量形式插入容器前端
template <class T>
void vectorInsertFront(vector<T> *v, const T *collection, int size)
{
    for(int k = 0; k < size; k++){
       v->insert(v->begin(), collection[k]);
    }
}

//列表形式插入
template <class T>
void listInsert(list<T> *l, const T *collection, int size)
{
    for(int k = 0; k < size; k++){
       l->push_back(collection[k]);
    }
}

//列表形式插入容器前端
template <class T>
void listInsertFront(list<T> *l, const T *collection, int size)
{
    for(int k = 0; k < size; k++){
       l->push_front(collection[k]);
    }
}

//多重集中形式插入
template <class T>
void multisetInsert(multiset<T> *s,const T *collection, int size)
{
    for(int k = 0; k < size; k++){
       s->insert(collection[k]);
    }
}

//产生随机元素函数
int *genInitData(int size)
{
    int *data = new int[size];
    generate(&data[0], &data[size],rand);
    return data;
}

//各个容器插入性能对比
void Insert_Perfor()
{
    QueryPerformanceFrequency(&cpuFreq);  //获取系统时钟的频率
    const int size = 1000000;
    //int array_data[1000000] = {0};  //直接分配的int类型数组在栈空间上的大小有限。有问题
    int *data = genInitData(size);
    int *array_data = new int[size];
    QueryPerformanceCounter(&startTime);
    arrayInsert(array_data,data,size);
    QueryPerformanceCounter(&endTime);

    run_time = (((endTime.QuadPart - startTime.QuadPart) * 1000.0) / cpuFreq.QuadPart);
    cout << "arrayInsert run_time: "<< run_time <<"ms" << endl;

    vector<int> vec_data;
    QueryPerformanceCounter(&startTime);
    vectorInsert(&vec_data,data,size);
    QueryPerformanceCounter(&endTime);
    run_time = (((endTime.QuadPart - startTime.QuadPart) * 1000.0) / cpuFreq.QuadPart);
    cout << "vectorInsert run_time: "<< run_time <<"ms" << endl;

    list<int> list_data;
    QueryPerformanceCounter(&startTime);
    listInsert(&list_data,data,size);
    QueryPerformanceCounter(&endTime);
    run_time = (((endTime.QuadPart - startTime.QuadPart) * 1000.0) / cpuFreq.QuadPart);
    cout << "listInsert run_time: "<< run_time <<"ms" << endl;

    multiset<int> multiset_data;
    QueryPerformanceCounter(&startTime);
    multisetInsert(&multiset_data,data,size);
    QueryPerformanceCounter(&endTime);
    run_time = (((endTime.QuadPart - startTime.QuadPart) * 1000.0) / cpuFreq.QuadPart);
    cout << "multisetInsert run_time: "<< run_time <<"ms" << endl;
}

//向量和列表插入容器前端性能对比
void Insert_Front_Perfor()
{
    QueryPerformanceFrequency(&cpuFreq);  //获取系统时钟的频率
    const int size_front = 100000;
    int *data_front = genInitData(size_front);
    vector<int> vec_front_data;
    QueryPerformanceCounter(&startTime);
    vectorInsertFront(&vec_front_data,data_front,size_front);
    QueryPerformanceCounter(&endTime);
    run_time = (((endTime.QuadPart - startTime.QuadPart) * 1000.0) / cpuFreq.QuadPart);
    cout << "vectorInsertFront run_time: "<< run_time <<"ms" << endl;

    list<int> list_front_data;
    QueryPerformanceCounter(&startTime);
    listInsertFront(&list_front_data,data_front,size_front);
    QueryPerformanceCounter(&endTime);
    run_time = (((endTime.QuadPart - startTime.QuadPart) * 1000.0) / cpuFreq.QuadPart);
    cout << "listInsertFront run_time: "<< run_time <<"ms" << endl;
}

int main()
{
    Insert_Perfor();
    Insert_Front_Perfor();
    while(1);
}

运行结果及分析：

数组性能远远优于其它容器原因是数组是直接分配内存包含100万个数据元素。但是向量、列表和多重集不会提前知道集合的大小，都是动态分配内存的。而且对于每一个数据，列表除了要为其设置前项指针和后向指针外，还要分配一个列表元素来存储数据。多重集一直保持其集合为有序的状态。

总结插入测试的测试结果：在知道集合大小的情况下，数组的性能最佳，在集合大下未知的情况下，插入整数，向量优于列表。将元素插入容器前端时，列表优于向量。

3.删除测试

案例：

//向量形式删除
template <class T>
void vectorDelete(vector<T> *v)
{
    while(!v->empty()){
        v->pop_back();
    }
}

//向量形式前端删除
template <class T>
void vectorDeleteFront(vector<T> *v)
{
    while(!v->empty()){
        v->erase(v->begin());
    }
}

//列表形式删除
template <class T>
void listDelete(list<T> *l)
{
    while(!l->empty()){
        l->pop_back();
    }
}

//列表形式前端删除
template <class T>
void listDeleteFront(list<T> *l)
{
    while(!l->empty()){
        l->pop_front();
    }
}

总结删除测试结果：（很多关于插入效率的结论同样适用于删除）

(1). 向量擅长于尾部对元素进行插入（或删除）操作。此操作与集合大小无关，是固定时间的操作。

(2). 除对集合尾部进行操作外，采用向量进行其他任何位置的插入（或删除）都是糟糕的选择。性能的损失与插入（或删除）点到向量尾部元素的距离成正比。（为什么？）

(3). 双向队列在集合的前端和尾部插入（或删除）元素效率都很高。在其他任何位置插入（或删除）元素效率都很低。

(4). 列表在集合的任何位置插入（或删除）元素效率都很高。

4. 遍历测试

案例：

.....

总结遍历测试结果：向量和数组的性能相同，并且远胜于列表。原因：容器遍历的关键元素为容器内存布局和系统缓存之间的交互作用。向量和数组的集合存储在连续内存空间，在物理存储器中是相邻的。当一个特定元素被加载到缓存中时，会同时加载相邻元素。（具体的个数由元素大小和缓存行大小决定）。列表容器不是这种情况，逻辑上相邻的列表元素在物理内存中未必相邻。列表除了存储元素值外，还必须存储前向指针和后向指针。单个元素占用内存空间过大，所以只有恨少的元素被载入缓存行。

5. 查找测试

案例：

总结 查找测试结果：当进行元素查找时，使用成员find()方法，多重集容器胜过其他容器。多重集容器的有序特性在查找方面带来巨大优势。

6. 使用函数对象的版本明显优于使用函数指针的版本，因为函数指针在运行时才被解析，无法被内联。而函数对象在编译时被确认，这使得编译器可以自由地内联operator()函数并显著提升性能。

7. 要点：

(1). STL是抽象、灵活性和效率的一种结合。它基本上实现了最好的算法。

(2). 每一个容器都有它的优劣势，要根据实际应用场景来判断使用哪种容器性能更好。

了解STL所忽略的问题，才能在特定的情况下，实现超过STL性能的算法。