C++ -- 学习系列 std::array 容器

news2024/11/28 2:30:44

1. std::array 是什么？

array 容器是 C++ 11 标准中新增的序列容器，简单地理解，它就是在 C++ 普通数组的基础上，添加了一些成员函数和全局函数。在使用上，它比普通数组更安全，且效率并没有因此变差。

与数组一样，其底层存储空间是连续的。

array 和其它容器不同，array 容器的大小是固定的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。

2. 使用方法

2.1. array 的模板参数：

1.1 T 代表 array 中元素的类型

1.2 N 代表 array 中元素的个数

namespace std{
    template <typename T, size_t N>
    class array;
}

2.1 使用例子:

// main.cpp
#include<array>
#include<string>
#include<iostream>
#include<memory>


template<typename T, size_t N>
void printArray(std::array<T, N>& arr)
{
//    for(int i=0; i<arr.size(); i++)
//    {
//        std::cout << arr[i] << " ";
//    }
    for(auto it = arr.begin(); it != arr.end(); it++)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}


void  testArray()
{
    // 两种初始化
    // 1. 列表初始化
    std::array<int, 6> arr1 = {1, 2, 3, 4, 5};

    // 2. 每个元素初始化
    std::array<int, 6> arr2;
    for(int i=0; i<5; i++)
    {
        arr2[i] = i+1;
    }

    std::cout << "print arr1 ---" << std::endl;
    printArray<int, 6>(arr1);

    std::cout << "print arr2 ---" << std::endl;
    printArray<int, 6>(arr2);
    
    std::array<int, 6> arr2(arr1);
}

int main()
{
  
    testArray();

    return 0;
}

3. 简单实现

// may_array.h

#include<initializer_list>
#include<iostream>

template<typename _Tp, int N>
class my_array
{
public:
    my_array();
    my_array(std::initializer_list<_Tp> valList);
    ~my_array();

    _Tp& operator[](int index)
    {
        return *(this->data + index);
    }

    _Tp& at(int index)
    {
        return this->operator[](index);
    }

    _Tp& front()
    {
        return *this->data;
    }

    _Tp& back()
    {
        return *(this->data + N - 1);
    }

    _Tp* begin()
    {
        return this->data;
    }

    _Tp* end()
    {
        return this->data + N;
    }

    const _Tp* const_begin()
    {
        return this->data;
    }

    const _Tp* const_end()
    {
        return this->data + N;
    }

private:
    _Tp *data;
    _Tp* iterator;
    const _Tp* const_iterator;

};

template<typename _Tp, int N>
my_array<_Tp, N>::my_array()
{
    this->data = new _Tp[N];
}

template<typename _Tp, int N>
my_array<_Tp, N>::~my_array()
{
    delete data;
}

template<typename _Tp, int N>
my_array<_Tp, N>::my_array(std::initializer_list<_Tp> valList)
{
    if(valList.size() != N){
        std::cout << "error arguments size not equals to "<< N << std::endl;
        return;
    }
    this->data = new _Tp[N];

    int i = 0;
    for(auto iter = valList.begin(); iter != valList.end(); iter++)
    {
        *(this->data + (i++)) = *iter;
    }
}



// main.cpp
#include<iostream>
#include<string>
#include"my_array.h"

template <typename V, int N>
void print(my_array<V, N>& arr)
{
    for(int i=0; i<N; i++)
    {
        std::cout << arr[i] << std::endl;
    }
}

int main(int argc, char *argv[])
{
    my_array<int, 6> arr1;
    for(int i = 0; i < 6; i++)
    {
        arr1[i] = i + 1;
    }

   for(auto iter = arr1.begin(); iter != arr1.end(); iter++)
   {
       std::cout << *iter << " ";
   }
   std::cout << "-------" <<std::endl;

   for(auto iter = arr1.const_begin(); iter != arr1.const_end(); iter++)
   {
       std::cout << *iter << " ";
   }
   std::cout << "-------" <<std::endl;


   my_array<std::string, 3> arr2 = {"aa", "bb", "cc"};
   for(auto iter = arr2.begin(); iter != arr2.end(); iter++)
   {
       std::cout << *iter << " ";
   }
   std::cout << "-------" <<std::endl;

   for(auto iter = arr2.const_begin(); iter != arr2.const_end(); iter++)
   {
       std::cout << *iter << " ";
   }
   std::cout << "-------" <<std::endl;

   return 0;
}