C++ STL序列式容器之array

最新推荐文章于 2024-02-19 11:34:57 发布
最新推荐文章于 2024-02-19 11:34:57 发布
阅读量414 收藏 3
点赞数
分类专栏： C++ STL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42704090/article/details/105223710
版权

C++ STL序列式容器之array

一、array概述

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

1、array容器创建对象的格式

array<T, N>  value; //创建array对象

注意事项：
1）、使用 array 容器类型时，需要在源文件中包含头文件 array；
2）、T 用于指明容器中存储的具体数据类型，N 用于指明容器的大小，需要注意的是，这里的 N 必须是常量，不能用变量表示

2、特性

1）、和常规数组没有太大的差别，不能增加或删除元素；
2）、模板实例的元素被内部存储在标准数组中；
3）、和标准数组相比，array 容器的额外幵销很小；
4）、array容器的两个优点：
–>如果使用 at()访问数据时，当用一个非法的索引访问数组元素时，能够被检测到，因为容器知道它有多少个元素；
–>数组容器可以作为参数传给函数，而不再需要单独去指定数组元素的个数

二、array容器的使用

1、array对象初始化的方式

1）、使用初始化列表{ }初始化

array<int, 10> value {}; //将所有的元素初始化为 0 或者和默认元素类型等效的值
array<int, 10> value {1, 2, 3, 4}; //列表中的 4 个值用于初始化前 4 个元素，其余的元素都将为 0

2）、调用数组对象的成员函数 fill()初始化

array<int, 10> value;
value.fill(3); //将所有元素都设为3

fill() 函数将所有元素都设为传入的实参值
程序示例：

#include <iostream>
#include <array>

using namespace std;

int main()
{
    array<int, 5> value1 {};
    cout << " 默认初始化：" << endl;
    for (auto a : value1)
        cout << "value = " << a << endl;
    cout << endl;

    array<int, 5> value2 {1, 2, 3};
    cout << " 部分初始化：" << endl;
    for (auto a : value2)
        cout << "value = " << a << endl;
    cout << endl;

    array<int, 5> value3;
    value3.fill(10);
    cout << "fill()初始化：" << endl;
    for (auto a : value3)
        cout << "value = " << a << endl;

    return 0;
}

结果：
在这里插入图片描述

3）、用函数模板 iota()以连续的递增值初始化一个数组容器，它定义在头文件 numeric 中

程序示例：

#include <iostream>
#include <array>
#include <numeric>

using namespace std;

int main()
{
    array<int, 5> myarray;
    iota(begin(myarray), end(myarray), 1); //从1开始递增

    for (auto a : myarray)
        cout << a << ' ';

    return 0;
}

运行结果：1 2 3 4 5

2、获取array元素的方式

可通过以下函数获取array容器的元素:
在这里插入图片描述
各个成员函数的用法及说明如下：

注：
1）、成员类型reference和const_reference是对数组元素的引用类型
2）、成员类型size_type是无符号整数类型size_t的别名

1、成员函数operator[]：
1）、函数原型：
reference operator[] (size_type n);
const_reference operator[] (size_type n) const;
2）、参数：元素在数组中的位置，第一个元素的位置为0而不是1
3）、返回值：返回对数组容器中位置n处元素的引用，如果数组对象是const限定的，则该函数返回const_reference。否则，它返回一个reference
4）、异常安全：如果容器的大小大于n，则该函数从不抛出异常（无抛出保证）
5）、返回的引用可用于访问或修改元素。同时访问或修改不同的元素是安全的。

程序示例：

// array::operator[]
#include <iostream>
#include <array>

using namespace std;

int main ()
{
    array<int, 10> myarray;

    // 初始化:
    for (int i = 0; i < 10; i++)
        myarray.at(i) = i + 1;

    // 打印:
    cout << "myarray contains:";
    for (int i = 0; i < 10; i++)
        cout << ' ' << myarray[i];
    cout << '\n';

    return 0;
}

运行结果：myarray contains: 1 2 3 4 5 6 7 8 9 10

2、成员函数 at()：
1）、函数原型：
reference at ( size_type n );
const_reference at ( size_type n ) const;
2）、参数：元素在数组中的位置，第一个元素的位置为0而不是1
3）、返回值：返回数组中位置n处元素的引用，如果数组对象是const限定的，则该函数返回const_reference。否则，它返回一个reference
4）、异常安全：at()会进行下标越界的检查，当传给 at() 的索引是一个越界值时，这时会抛出 std::out_of_rang 异常；
5）、返回的引用可用于访问或修改元素。同时访问或修改不同的元素是安全的

程序示例：

// array::at()
#include <iostream>
#include <array>

using namespace std;

int main ()
{
    array<int, 10> myarray;

    // 初始化:
    for (int i = 0; i < 10; i++)
        myarray.at(i) = i + 1;

    // 打印:
    cout << "myarray contains:";
    for (int i = 0; i < 10; i++)
        cout << ' ' << myarray.at(i);
    cout << '\n';

    return 0;
}

运行结果：myarray contains: 1 2 3 4 5 6 7 8 9 10

3、成员函数front()
1）、函数原型：
reference front();
const_reference front() const;
2）、参数：无参数
3）、返回值：返回对数组容器中第一个元素的引用，如果数组对象是const限定的，则该函数返回const_reference。否则，它返回一个reference。
4）、异常安全：如果容器不为空，则该函数永远不会抛出异常（无抛出保证）。
否则，它将导致未定义的行为。
5）、返回的引用可用于访问或修改元素。同时访问或修改不同的元素是安全的。

程序示例：

// array::front()
#include <iostream>
#include <array>

using namespace std;

int main()
{
    array<int, 3> myarray = {2, 16, 77};

    cout << "front is: " << myarray.front() << endl;   // 2
    cout << "back is: " << myarray.back() << endl;     // 77

    myarray.front() = 100;

    cout << "myarray now contains:";
    for ( int& x : myarray )
        cout << ' ' << x;
    cout << '\n';

    return 0;
}

运行结果：

front is: 2
back is: 77
myarray now contains: 100 16 77

4、成员函数back()
1）、函数原型：
reference back();
const_reference back() const;
2）、参数：无参数
3）、返回值：返回对数组容器中最后一个元素的引用，如果数组对象是const限定的，则该函数返回const_reference。否则，它返回一个reference。
4）、异常安全：如果容器不为空，则该函数永远不会抛出异常（无抛出保证）。
否则，它将导致未定义的行为。
5）、返回的引用可用于访问或修改元素。同时访问或修改不同的元素是安全的。

程序示例同front()。

5、成员函数data()
1）、函数原型：
value_type* data() noexcept;
const value_type* data() const noexcept;
2）、参数：无参数
3）、返回值：返回指向数组对象中第一个元素的指针，如果数组对象是const限定的，则该函数返回的指针为 const value_type。否则，它返回一个指向value_type类型指针。
4）、异常安全：此成员函数不会抛出异常
5）、调用不会直接访问任何包含的元素，但是返回的指针可用于访问或修改元素。同时访问或修改不同的元素是安全的

程序示例：

// array::data
#include <iostream>
#include <cstring>
#include <array>

int main ()
{
  const char* cstr = "Test string";
  std::array<char, 12> charray;

  std::memcpy(charray.data(), cstr, 12);

  std::cout << charray.data() << '\n';

  return 0;
}

运行结果：Test string

6、使用非成员函数 get() ，它能够获取到容器的第 n 个元素

#include <iostream>
#include <array>

using namespace std;

int main()
{
    array<int, 5> myarray {1, 2, 3};
    cout << get<2>(myarray) << '\n';

    return 0;
}

运行结果：3

3、array迭代器

迭代器的作用是遍历array数组类中的元素

迭代器函数：
在这里插入图片描述
各个成员函数的用法及说明如下：

正向迭代器begin()和end()

1、成员函数begin()
1）、函数原型：
iterator begin() noexcept;
const_iterator begin() const noexcept;
2）、参数：无参数
3）、返回值：返回指向数组容器中第一个元素的迭代器，如果数组对象是const限定的，则该函数返回const_iterator。否则，它返回一个iterator。
成员类型iterator和const_iterator是随机访问迭代器类型（分别指向元素和const元素）。
4）、异常安全：不会抛出异常。返回的迭代器的复制构造函数或者赋值运算也不会抛出
5）、不会访问容器中的元素，但是返回的迭代器可用于访问或修改元素。同时访问或修改不同的元素是安全的

2、成员函数end()
1）、函数原型：
iterator end() noexcept;
const_iterator end() const noexcept;
2）、参数：无参数
3）、返回值：返回指向最后一个元素的下一个位置的随机访问迭代器，在零大小的数组中，此函数返回的结果与array :: begin相同。如果数组对象是const限定的，则该函数返回const_iterator。否则，它返回一个iterator
4）、异常安全：不会抛出异常。返回的迭代器的复制构造函数或者赋值运算也不会抛出
5）、不会访问容器中的元素，但是返回的迭代器可用于访问或修改元素。同时访问或修改不同的元素是安全的

程序示例：

// array::begin（） and end（） example
#include <iostream>
#include <array>

int main ()
{
  std::array<int,5> myarray = { 5, 19, 77, 34, 99 };

  std::cout << "myarray contains:";
  for ( auto it = myarray.begin(); it != myarray.end(); ++it )
    std::cout << ' ' << *it;

  std::cout << '\n';

  return 0;
}

运行结果：myarray contains: 5 19 77 34 99

反向迭代器rbegin()和rend()

3、成员函数rbegin()
1）、函数原型：
reverse_iterator rbegin（）noexcept;
const_reverse_iterator rbegin（）const noexcept;
2）、参数：无参数
3）、返回值：返回指向容器中的最后一个元素的位置，如果数组对象是const限定的，则该函数返回const_iterator。否则，它返回一个iterator。
成员类型iterator和const_iterator是反向随机访问迭代器类型（分别指向元素和const元素）。
4）、异常安全：不会抛出异常。返回的迭代器的复制构造函数或者赋值运算也不会抛出
5）、不会访问容器中的元素，但是返回的迭代器可用于访问或修改元素。同时访问或修改不同的元素是安全的

4、成员函数rend()
1）、函数原型：
reverse_iterator rend（）noexcept;
const_reverse_iterator rend（）const noexcept;
2）、参数：无参数
3）、返回值：返回指向数组中第一个元素的前一个位置，如果数组对象是const限定的，则该函数返回const_iterator。否则，它返回一个iterator。
成员类型iterator和const_iterator是反向随机访问迭代器类型（分别指向元素和const元素）。
4）、异常安全：不会抛出异常。返回的迭代器的复制构造函数或者赋值运算也不会抛出
5）、不会访问容器中的元素，但是返回的迭代器可用于访问或修改元素。同时访问或修改不同的元素是安全的

程序示例：

// array::rbegin/rend
#include <iostream>
#include <array>

int main ()
{
  std::array<int,4> myarray = {4, 26, 80, 14} ;

  std::cout << "myarray contains:";
  for ( auto rit=myarray.rbegin() ; rit < myarray.rend(); ++rit )
    std::cout << ' ' << *rit;

  std::cout << '\n';

  return 0;
}

运行结果：myarray contains: 14 80 26 4

5、成员函数cbegin()
1）、函数原型：
const_iterator cbegin（）const noexcept;
2）、参数：无参数
3）、返回值：返回指向const数组容器中第一个元素的位置
4）、异常安全：不会抛出异常。返回的迭代器的复制构造函数或者赋值运算也不会抛出
5）、不会访问容器中的元素，但是返回的迭代器可用于访问它们。同时访问或修改不同的元素是安全的

6、成员函数cend()
1）、函数原型：
const_iterator cend（）const noexcept;
2）、参数：无参数
3）、返回值：返回指向const数组容器中最后一个元素的下一个位置，
4）、异常安全：不会抛出异常。返回的迭代器的复制构造函数或者赋值运算也不会抛出
5）、不会访问容器中的元素，但是返回的迭代器可用于访问元素。同时访问或修改不同的元素是安全的

程序示例：

// array::cend example
#include <iostream>
#include <array>

int main ()
{
  std::array<int, 5> myarray = { 15, 720, 801, 1002, 3502 };

  std::cout << "myarray contains:";
  for ( auto it = myarray.cbegin(); it != myarray.cend(); ++it )
    std::cout << ' ' << *it;   // cannot modify *it

  std::cout << '\n';

  return 0;
}

运行结果：myarray contains: 15 720 801 1002 3502

7、成员函数rcbegin()
1）、函数原型：
const_reverse_iterator crbegin（）const noexcept;
2）、参数：无参数
3）、返回值：返回指向数组容器中最后一个元素的const_reverse_iterator，类型const_reverse_iterator是指向const元素的反向随机访问迭代器类型
4）、异常安全：不会抛出异常。返回的迭代器的复制构造函数或者赋值运算也不会抛出
5）、不会访问容器中的元素，但是返回的迭代器可用于访问它们。同时访问或修改不同的元素是安全的

8、成员函数rcend()
1）、函数原型：
const_reverse_iterator crend（）const noexcept;
2）、参数：无参数
3）、返回值：返回指向const数组容器中第一个元素的前一个位置，返回类型为const_reverse_iterator，类型const_reverse_iterator是指向const元素的反向随机访问迭代器类型
4）、异常安全：不会抛出异常。返回的迭代器的复制构造函数或者赋值运算也不会抛出
5）、不会访问容器中的元素，但是返回的迭代器可用于访问元素。同时访问或修改不同的元素是安全的

程序示例：

// array::crbegin/crend
#include <iostream>
#include <array>

int main ()
{
  std::array<int,6> myarray = {10, 20, 30, 40, 50, 60} ;

  std::cout << "myarray backwards:";
  for ( auto rit = myarray.crbegin() ; rit < myarray.crend(); ++rit )
    std::cout << ' ' << *rit;   // cannot modify *rit

  std::cout << '\n';

  return 0;
}

运行结果：myarray backwards: 60 50 40 30 20 10

4、获取array容器的容量

可通过以下函数获取容器的容量信息:
在这里插入图片描述

1、成员函数size()
1）、函数原型：
constexpr size_type size（）noexcept;
2）、参数：无参数
3）、返回值：返回数组容器中的元素数，与运算符sizeof（以字节为单位返回大小）不同，该成员函数以元素数的形式返回数组的大小
4）、异常安全：不会抛出异常
5）、不会访问容器中的元素，同时访问或修改不同的元素是安全的

程序示例：

// array::size
#include <iostream>
#include <array>

int main ()
{
  std::array<int,5> myints;
  std::cout << "size of myints: " << myints.size() << std::endl;
  std::cout << "sizeof(myints): " << sizeof(myints) << std::endl;

  return 0;
}

运行结果：

size of myints: 5
sizeof(myints): 20

2、成员函数max_size()
1）、函数原型：
constexpr size_type max_size（）noexcept;
2）、参数：无参数
3）、返回值：返回数组容器可以容纳的最大元素数
4）、异常安全：不会抛出异常
5）、不会访问容器中的元素，同时访问或修改不同的元素是安全的

程序示例：

// array::max_size
#include <iostream>
#include <array>

int main ()
{
  std::array<int, 10> myints;
  std::cout << "size of myints: " << myints.size() << '\n';
  std::cout << "max_size of myints: " << myints.max_size() << '\n';

  return 0;
}

运行结果：

size of myints: 10
max_size of myints: 10

3、成员函数empty()
1）、函数原型：
constexpr bool empty（）noexcept;
2）、参数：无参数
3）、返回值：返回一个布尔值
4）、异常安全：不会抛出异常
5）、不会访问容器中的元素，同时访问或修改不同的元素是安全的

程序示例：

// array::empty
#include <iostream>
#include <array>

int main ()
{
  std::array<int,0> first;
  std::array<int,5> second;
  std::cout << "first " << (first.empty() ? "is empty" : "is not empty") << '\n';
  std::cout << "second " << (second.empty() ? "is empty" : "is not empty") << '\n';
  return 0;
}

运行结果：

first is empty
second is not empty

5、修改array容器的元素

在这里插入图片描述

1、成员函数fill()
1）、函数原型：
void fill (const value_type& val);
2）、参数：整型
3）、返回值：无
4）、异常安全：会抛出异常
5）、容器中所有元素的值被修改为传入的参数值

程序示例：

// array::fill example
#include <iostream>
#include <array>

int main () 
{
  std::array<int,6> myarray;

  myarray.fill(5);

  std::cout << "myarray contains:";
  for ( int& x : myarray) { std::cout << ' ' << x; }

  std::cout << '\n';

  return 0;
}

运行结果：

myarray contains: 5 5 5 5 5 5

2、成员函数swap()
1）、函数原型：

void swap (array& x) noexcept(noexcept(swap(declval<value_type&>(), declval<value_type&>())));

2）、参数：与X类型相同（包括相同大小）数组容器
3）、返回值：无
4）、异常安全：如果调用非成员方法swap在该类型的元素不会抛出异常，那么该方法也不会抛出异常。否则，容器保证在有效的状态。
5）、参数容器和X均被修改。调用可访问两个容器中的所有元素

程序示例：

// array::fill example
#include <iostream>
#include <array>

int main () 
{
  std::array<int,6> myarray;

  myarray.fill(5);

  std::cout << "myarray contains:";
  for ( int& x : myarray) { std::cout << ' ' << x; }

  std::cout << '\n';

  return 0;
}

运行结果：

first: 11 22 33 44 55
second: 10 20 30 40 50

6、关系运算符

//(1)	
template <class T, size_T N>
  bool operator== ( const array<T,N>& lhs, const array<T,N>& rhs );
//(2)	
template <class T, size_T N>
  bool operator!= ( const array<T,N>& lhs, const array<T,N>& rhs );
//(3)	
template <class T, size_T N>
  bool operator<  ( const array<T,N>& lhs, const array<T,N>& rhs );
//(4)	
template <class T, size_T N>
  bool operator<= ( const array<T,N>& lhs, const array<T,N>& rhs );
//(5)	
template <class T, size_T N>
  bool operator>  ( const array<T,N>& lhs, const array<T,N>& rhs );
//(6)	
template <class T, size_T N>
  bool operator>= ( const array<T,N>& lhs, const array<T,N>& rhs );

程序示例：

// array comparisons
#include <iostream>
#include <array>

int main ()
{
  std::array<int,5> a = {10, 20, 30, 40, 50};
  std::array<int,5> b = {10, 20, 30, 40, 50};
  std::array<int,5> c = {50, 40, 30, 20, 10};

  if (a==b) std::cout << "a and b are equal\n";
  if (b!=c) std::cout << "b and c are not equal\n";
  if (b<c) std::cout << "b is less than c\n";
  if (c>b) std::cout << "c is greater than b\n";
  if (a<=b) std::cout << "a is less than or equal to b\n";
  if (a>=b) std::cout << "a is greater than or equal to b\n";

  return 0;
}

运行结果：

a and b are equal
b and c are not equal
b is less than c
c is greater than b
a is less than or equal to b
a is greater than or equal to b

参考：
1、C++ STL容器参考手册
2、C语言中文网

墨上烟雨
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++容器 array
F_Just
05-15 246
C++容器 array C++ 11 中将数组抽象成了一个模板类array。 array 位于名称空间 std 中，与数组一样， array 的长度是固定的，也使用栈（静态内存分配），而不是自由存储区，因此其效率与数组相同，但更方便，更安全。 零大小的数组是有效的，不应取消引用（成员 front() ， back() 和 data() ）。 与标准库中的其他容器不同，交换两个数组容器是一种线性操作，涉及单独交换范围内的所有元素，这通常效率较低。另一方面，这允许迭代器访问两个容器中的元素，以保持其原始容器关联
array-C++容器
C++的知识
12-01 164
C++容器之array
C++容器——静态数组（array）
shouhu010的博客
03-10 544
容器array 固定数值 定义 初始化 迭代器 基本操作
C++ -- 学习系列 std::array 容器
qq_33775774的博客
09-17 610
array 容器是11 标准中新增的序列容器，简单地理解，它就是在 C++ 普通数组的基础上，添加了一些成员函数和全局函数。在使用上，它比普通数组更安全，且效率并没有因此变差。与数组一样，其底层存储空间是连续的。array 和其它容器不同，array 容器的大小是的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。
STL序列容器详解之Array
AndyJ的学习之旅
04-29 269
参考链接 array 容器 array 容器是 C++ 11 标准中新增的序列容器，简单地理解，它就是在 C++ 普通数组的基础上，添加了一些成员函数和全局函数。 和其它容器不同，array 容器的大小是固定的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。 array 容器以类模板的形式定义在 <array> 头文件，并位于命名空间 std 中 #include <array> using namespac
STL常用容器1
08-03
在本文中，我们将重点讨论STL中的容器，特别是序列式容器和关联式容器。 1. 序列式容器： 序列式容器是一类按照元素插入顺序存储的容器，包括vector、queue、deque、priority_queue、list和stack。这些容器有着...
C++ 标准程式库
03-04
- **数组（Array）**：提供固定大小的数组，具有内置数组的特性，但支持STL接口。 - **向量（Vector）**：动态大小的数组，可以在两端进行插入和删除操作。 - **列表（List）**：双向链表，支持高效地在任何位置...
stl数据结构.docx
最新发布
03-01
C++ STL (Standard Template Library标准模板库) 是通用类模板和算法的集合，它提供给程序员一些标准的数据结构的实现，称为容器，如 queues(队列)、lists(链表)、和 stacks(栈)等。 STL容器是由一些运用最广的一些...
Cplusplus_Piscine：实现C ++标准模板库的各种容器类型。 容器是：
02-10
1. **数组（Array）**：这是最基础的容器，它提供固定大小的元素序列。C++11引入了一个新的`std::array`容器，它提供了更安全、更现代的数组操作方式。 2. **向量（Vector）**：`std::vector`是一个动态数组，可以...
《C++编程艺术》教程+代码
02-04
8.3.2 序列式容器的其他要求 211 8.3.3 关联式容器的要求 211 8.4 创建范围可选的动态数组容器 212 8.4.1 RangeArray的运行方式 212 8.4.2 完整的RangeArray类 213 8.4.3 详细讨论RangeArray类 224 8.4.4 一些Range...
STL容器-----array数组
weixin_43743711的博客
08-05 327
前言： C++11中引入了array容器，array是序列容器的一种。array很类似于一般的数组，例如，array在栈上分配连续的内存来储存元素，并且array的大小是不可以改变的，这也就是说，可以修改array中元素的值，但不能向array中插入和删除元素 其次：array是原生数组的封装，它存放于栈上且大小固定，性能也与之相同。在原生数组的基础上，它添加了范围检查，以及其它的STL的相应特性，比如复制、交换、迭代器、查询大小。 初始化 Array数组没有构造函数，也没有私有或保护成员，这就意味着它不会
C++ 容器详解
暖心~的博客
04-14 6116
顺序容器：此处的顺序不是体现在元素的值的顺序，而是指的是元素加入容器时的位置相对应的。 关联容器：顺序容器分类： 类型 特点 vector 可变大小数组 支持快速随机访 在尾部之外的位置插入或删除元素可能很慢。 deque 双端队列 支持快速随机访问 在头尾位置插入/删除速度很快 list 双向链表 只支持双向顺序访问 在list的
STL【容器】 | 【01】Array
weixin_45926547的博客
03-31 211
文章目录1、array1.1 常用成员函数1.2 案例 1、array 相当于数组，存储固定大小的具有相同数据类型的序列容器； 元素存储在连续的内存位置，允许对元素随机访问； template < class T, size_t N > class array; 1.1 常用成员函数 empty()：判断是否为空； size()：返回当前实际元素个数； max_size()：返回最大大小； [ ]：返回指定下标的元素； at：通过索引获取元素； front()：获取第一个元素；
STL总结之array
YangLei253的博客
07-25 759
介绍 array 是一个封装普通数组的顺序容器，其数组大小固定，可以使用索引位置访问元素，受限地在尾部插入和删除元素，但是受限地在中部插入或删除元素是比较麻烦的 (受限指的是可能因为数组大小原因，导致操作失败)。 array 定义于头文件 <array>，其声明如下： template< class T, std::size_t N > struct array; ...
【C++】《C++ 17 入门经典》读书笔记 07----数组的替代品之一： std::array 容器
风语留痕
06-29 532
介绍 C++17 中的数组替代品之一： std::array<T, N>容器。
C++ array容器用法详解
Lemon_C17y的博客
02-19 2230
除此之外，C++ 11 标准库还新增加了 begin() 和 end() 这 2 个函数，和 array 容器包含的 begin() 和 end() 成员函数不同的是，标准库提供的这 2 个函数的操作对象，既可以是容器，还可以是普通数组。当操作对象是容器时，它和容器包含的 begin() 和 end() 成员函数的功能完全相同；和其它容器不同，array 容器的大小是固定的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。
C++中实现数组乘法
我想要去航海的博客
07-28 4247
C++中实现数组乘法 在原来两个二维数组的基础上需要再引入一个变量加入for循环。 实现二维数组相乘函数时传入数组的注意事项 #include<iostream> using namespace std; #include <stdio.h> #define np 4 #define nt 3 //实现数组乘法的函数 int ArrMul(int arr1[][nt], int size1,int arr2[][1],int size2,int c[][1],int size3)
bytearray-string
junjun5156的博客
05-21 680
#按string来显示,byarray代表bytes数据 readstr = byarray.decode('utf-8')#这样就直接转换成str格式#强制转换 readstr = str(byarray)#用这种方式得到的数据会带有b''字符#将读取的数据按十六进制字符显示，能让我们直接看到最底层的数据格式 readstr = ' '.join(hex(x) for x in byarray)#
2021-11-21STL——array&deque
weixin_51187533的博客
11-27 375
array实现用类对数组的封装，这样可以使用 algorithm 对其进行操作。 其容量不可扩展。 使用 native pointer 作为 iterator，这点与 vector 一致。 如果申请一个大小为 0 的数组会自动扩充到 1 . deque map（T**）指向整个“控制中心”，每个控制中心的单元都指向存放元素的大块内存 buffer ，大块内存里面放置了元素。 iterator内含4个指针： 1）first（T*）—— buffer 开始的位置 2）last(T*)—— buffer 结束.
C++ STL入门：序列式容器与算法解析
"序列式容器-STL算法入门ppt" 这篇PPT主要介绍了序列式容器，特别是STL（Standard Template Library）中的核心概念，包括迭代器、容器、算法和配接器。STL是C++标准库的一个重要组成部分，它通过模板（Template）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值