07--STL序列容器（Array）

一：Array了解

array<T,N> 模板定义了一种相当于标准数组的容器类型。
它是一个有 N 个 T 类型元素的固定序列。除了需要指定元素的类型和个数之外，它和常规数组没有太大的差别。

模板实例的元素被内部存储在标准数组中。
和标准数组相比，array 容器的额外幵销很小，---->比标准数组还是大一些
但提供了两个优点：

1.std::array除了有传统数组支持随机访问、效率高、存储大小固定等特点外，还支持迭代器访问、获取容量、获得原始指针等高级功能。
而且它还不会退化成指针T *给开发人员造成困惑。

2.如果使用 at()，当用一个非法的索引访问数组元素时，能够被检测到，因为容器知道它有多少个元素，
这也就意味着数组容器可以作为参数传给函数，而不再需要单独去指定数组元素的个数。

注意：

其中的元素是一个有序的集合

允许随机访问

其迭代器属于随机迭代器

其size()的结果总等于N

不支持分配器　　//像vector，deque动态分配空间是需要分配器来实现的

是唯一一个无任何东西被指定为初值时，会被预初始化的容器，这意味着对于基础类型初值可能不明确

class array<> 是一个聚合体(不带用户提供的构造函数，没有private和protected的nonstatic数据成员，没有base类，有没有virtual 函数），
这意味着保存所有元素的那个成员是public，然而C++并没有指定其名称，因此对该public成员的任何直接访问都会导致不可预期的行为，也绝对不可移植。

二：array构造

array<Elem,N> c //默认构造函数; 创建一个默认初始化的数组

array<Elem,N> c(c2) //复制构造函数; 创建另一个与c2同型的vector副本(所有元素都被复制)

array<Elem,N> c = c2 //复制构造函数; 创建另一个与c2同型的vector副本(所有元素都被复制)

array<Elem,N> c(rv) //移动构造函数; 拿走右值rv的元素创建一个新的数组

array<Elem,N> c = rv //移动构造函数; 拿走右值rv的元素创建一个新的数组

array<Elem,N> c = initlist //使用初始化列表创建一个初始化的数组

三：array元素存取

c[idx] //返回索引idx所标示的元素，不进行范围检查

c.at(idx) //返回索引idx所标示的元素，如果越界，抛出range-error

c.front() //返回第一个元素，不检查第一个元素是否存在

c.back() //返回最后一个元素，不检查最后一个元素是否存在

四：array赋值操作

c = c2 //将c2所有元素赋值给c

c = rv //将右值对象rv的所有元素移动赋值给c

c.fill(val) //将val赋值给数组c里的每个元素

c1.swap(c2) //交换c1和c2的数

swap(c1,c2) //交换c1和c2的数

如果使用=操作符或者swap()，两个array必须具备相同类型，即元素类型和大小必须相同。

五：迭代相关函数

c.begin() //返回一个随机存取迭代器，指向第一个元素

c.end() //返回一个随机存取迭代器，指向最后一个元素

c.cbegin() //返回一个随机存取常迭代器，指向第一个元素

c.cend() //返回一个随机存取常迭代器，指向最后一个元素

c.rbegin() //返回一个逆向迭代器，指向逆向迭代的第一个元素

c.rend() //返回一个逆向迭代器，指向逆向迭代的最后一个元素

c.crbegin() //返回一个逆向常迭代器，指向逆向迭代的第一个元素

c.crend() //返回一个逆向常迭代器，指向逆向迭代的最后一个元素

    array<int, > arr = {,,,,,};    //默认补全0

    for (array<int, >::iterator iter = arr.begin(); iter != arr.end(); iter++)
    {
        cout << *iter << " ";
    }

六：性能测试

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <stdio.h>
#include <cstring>

#if _MSC_VER
#define snprintf _snprintf
#endif

using namespace std;

long get_a_target_long()
{
    /******变量声明********/
    long target = ;
    /**********************/

    cout << "targer (0~" << RAND_MAX << "):";
    cin >> target;
    return target;
}

string get_a_target_string()
{
    /******变量声明********/
    long target = ;
    char buf[];
    /**********************/

    cout << "targer (0~" << RAND_MAX << "):";
    cin >> target;

    snprintf(buf, , "%d", target);
    return string(buf);
}

//与后面的比较函数中回调参数对应
int compareLongs(const void* l1, const void* l2)
{
    return (*(long*)l1 - *(long*)l2);
}

int compareStrings(const void* s1, const void* s2)
{
    if (*(string*)s1 > *(string*)s2)
        return ;
    if (*(string*)s1 < *(string*)s2)
        return -;
    return ;
}

公共函数

/************************************************************************/
/*测试数组                                                                      */
/************************************************************************/
#include <array>
#include <iostream>
#include <algorithm>
#include <ctime>
#include <cstdlib>

#define ASIZE 200000    //由于数组声明需要使用常量值，故在这里写死
//500000个long---4000000Byte---4M

//数组Array测试
namespace jj01
{
    void test_array()
    {
        cout << "\ntest_array()*******" << endl;

        /******变量声明:数组初始********/
        array<long, ASIZE> arr;

        /******变量声明：记录时间********/
        clock_t timeStart = clock();    //开始时间
        for (long i = ; i < ASIZE; i++)
            arr[i] = rand();    //0-32767，所以有重复

        cout << "inti array use milli-seconds:" << (clock() - timeStart) << endl;    //获取初始化数组耗时
        cout << "array.size:" << arr.size() << endl;    //获取数组大小
        cout << "array.front:" << arr.front() << endl;    //获取数组首元素
        cout << "array.back:" << arr.back() << endl;    //获取数组尾元素
        cout << "array.data:" << arr.data() << endl;    //获取数组首地址

        /******变量声明：获取我们要查询的数********/
        long target = get_a_target_long();

        timeStart = clock();

        //qsort和bsearch是C编译器自带的快速排序和二分查找算法
        qsort(arr.data(), ASIZE, sizeof(long), compareLongs);

        /******变量声明：pItem是我们获取的返回的元素地址********/
        long* pItem =
            (long*)bsearch(&target, arr.data(), ASIZE, sizeof(long), compareLongs);
        cout << "qsort()+bsearch(),milli-seconds:" << clock() - timeStart << endl;
        if (pItem != NULL)
            cout << "found:" << *pItem << endl;
        else
            cout << "not found!" << endl;

        random_shuffle(arr.begin(), arr.end());    //乱序

        //STL排序查找算法
        timeStart = clock();

        sort(arr.begin(), arr.end());
        /******变量声明：flag布尔型判断是否找到数据********/
        bool flag =
            binary_search(arr.begin(), arr.end(), target);

        cout << "sort()+binary_search(),milli-seconds:" << clock() - timeStart << endl;
        if (flag != false)
            cout << "found:" << *pItem << endl;
        else
            cout << "not found!" << endl;

        //使用find方法进行查找
        timeStart = clock();

        auto pI = find(arr.begin(), arr.end(), target);

        cout << "::find(),milli-seconds:" << clock() - timeStart << endl;
        if (flag != false)
            cout << "found:" << *pI << endl;
        else
            cout << "not found!" << endl;
    }
}