目录

容器特性

构造函数

默认构造函数

填充构造函数

范围构造函数

拷贝构造函数

内存布局

大小函数

size() 函数

capacity() 函数

empty() 函数

resize() 函数

增加函数

push_back(const T& value)

emplace_back(Args&&... args)

push_back和emplace_back

iterator

insert(iterator position, const T& value)

insert(iterator position, size_type n, const T& val)

insert( position, InputIterator first, InputIterator last)

删除函数

pop_back()

erase(iterator position)

erase(iterator first, iterator last)

clear()

修改函数

使用下标操作符[]

使用at()​​成员函数

使用迭代器

使用front()​​和back()​​成员函数

查找函数

std::find

std::find_if

---

容器特性

• C++ 中的 vector 容器是一个动态数组，它提供了一种能够在运行时调整大小的数组结构。它属于标准模板库（STL）的一部分，定义在 <vector>​​​​​ 头文件中。

• vector容器特性

  • 动态大小: vector 容器可以在运行时动态调整大小，可以根据需要自动增长或缩小。这使得在不知道需要存储多少元素的情况下使用 vector 变得更加灵活。
  • 连续存储: vector 容器的元素在内存中是连续存储的，这使得元素的访问更加高效。
  • 动态添加和删除: vector 容器提供了在任意位置插入和删除元素的方法。这使得在向量的任意位置进行插入、删除和修改操作变得容易。
  • 随机访问: 可以通过索引直接访问 vector 容器中的元素，这使得在需要快速访问元素的场景中非常有用。
  • 自动内存管理: vector 容器自动管理内存分配和释放，无需手动处理内存分配和释放的细节。当向量的大小超过当前分配的内存时，它会自动重新分配更大的内存来容纳更多的元素。

构造函数

• 默认构造函数

  • 函数：默认构造函数

  • 用途：创建一个空的 std::vector​​ 容器。

  • 语法：std::vector<T> vec;​​

  • 返回值：无

    
    #include <vector>
    #include <iostream>
    
    int main() {
        std::vector<int> vec;
        std::cout << "Vector size: " << vec.size() << std::endl;
        return 0;
    }
    

• 填充构造函数

  • 函数：填充构造函数

  • 用途：创建一个具有特定大小的 std::vector​​，每个元素都初始化为传入的值。

  • 语法：std::vector<T> vec(n, value);​​

  • 返回值：无

    
    #include <vector>
    #include <iostream>
    
    int main() {
        std::vector<int> vec(5, 10); // 创建一个大小为5的vector，每个元素都是10
    
        for(int i : vec) {
            std::cout << i << ' ';
        }
        return 0;
    }
    

• 范围构造函数

  • 函数：范围构造函数

  • 用途：根据另一个容器或数组的范围创建一个 std::vector​​。

  • 语法：std::vector<T> vec(first, last);​​

  • 返回值：无

    
    #include <vector>
    #include <iostream>
    
    int main() {
        int array[] = {1, 2, 3, 4, 5};
        std::vector<int> vec(array, array + 5); // 从数组创建vector
    
        for(int i : vec) {
            std::cout << i << ' ';
        }
        return 0;
    }
    

• 拷贝构造函数

  • 函数：拷贝构造函数

  • 用途：创建一个新的 std::vector​​，作为另一个 std::vector​​ 的副本。

  • 语法：std::vector<T> vec(otherVector);​​

  • 返回值：无

    
    #include <vector>
    #include <iostream>
    
    int main() {
        std::vector<int> originalVec = {1, 2, 3, 4, 5};
        std::vector<int> vec(originalVec); // 使用originalVec创建vec
    
        for(int i : vec) {
            std::cout << i << ' ';
        }
        return 0;
    }
    

• 移动构造函数 (C++11 及以后)

  • 函数：移动构造函数

  • 用途：通过移动另一个 std::vector​​ 的资源（而不是拷贝）来创建一个新的 std::vector​​。

  • 语法：std::vector<T> vec(std::move(otherVector));​​

  • 返回值：无

    
    #include <vector>
    #include <iostream>
    
    int main() {
        std::vector<int> originalVec = {1, 2, 3, 4, 5};
        std::vector<int> vec(std::move(originalVec)); // 移动构造
    
    
        std::cout << "originalVec size: " << originalVec.size() << std::endl;
        std::cout << "vec size: " << vec.size() << std::endl;
        for(int i : vec) {
            std::cout << i << ' ';
        }
        return 0;
    }
    

• 内存布局

  • 开始指针（start）: 指向数组的起始位置。
  • 结束指针（end）: 指向数组最后一个元素之后的位置，用于迭代和确定大小。
  • 容量末尾指针（end of storage）: 指向分配的内存块末尾之后的位置，用于确定是否需要重新分配。
  • ​​

大小函数

• 大小函数

  • size() 函数

    • 用途：size()​​​​​函数用来返回vector​​​​​中当前存储的元素数量。
    • 语法：size_type size() const;​​​​​
    • 返回值：返回vector​​​​​当前包含的元素个数，类型为size_type​​​​​，这通常是一个无符号整型值。

  • capacity() 函数

    • 用途：虽然capacity()​​​​​并非直接用于获取vector​​​​​的“大小”，它用来返回vector​​​​​在重新分配内存之前能够存储的元素数量。这是vector​​​​​预分配的内存大小。
    • 语法：size_type capacity() const noexcept;​​​​​
    • 返回值：返回vector​​​​​在不进行内存重新分配的情况下能存储的最大元素数量。

  • empty() 函数

    • 用途：empty()​​​​​函数用来检查vector​​​​​是否为空，即是否不包含任何元素。
    • 语法：bool empty() const noexcept;​​​​​
    • 返回值：如果vector​​​​​为空则返回true​​​​​，否则返回false​​​​​。

  • resize() 函数

    • 用途：resize()​​​​​函数用来改变vector​​​​​的大小，即改变其包含的元素数量。如果新大小大于当前大小，会在vector​​​​​的末尾添加默认初始化的元素。如果新大小小于当前大小，则末尾的元素会被丢弃。
    • 语法：void resize(size_type n);​​​​​
    • 参数：n​​​​​是新的大小。

增加函数

• push_back(const T& value)

  • 用途：将一个新元素添加到vector​​​​的末尾。
  • 语法：void push_back(const T& value);​​​​
  • 返回值：无。

• emplace_back(Args&&... args)

  • 用途：在vector​​​​的末尾构造一个新元素，可以避免额外的复制或移动操作。
  • 语法：void emplace_back(Args&&... args);​​​​
  • 返回值：无

  • #include <iostream>
    #include <vector>
    
    class Person
    {
    public:
    	Person(const char* name, int nAge)
    	{
    		m_Name = name;
    		m_Age = nAge;
    	}
    	const char* m_Name;
    	int m_Age;
    };
    
    int main()
    {
    	std::vector<Person> vec;
    
    	Person p1("Tom", 18);
    	vec.push_back(p1);
    	//Error -> obj
    	//vec.push_back("Tom", 1);
    	vec.emplace_back("0xCC", 18);
    
    	return 0;
    }
    

• push_back和emplace_back

  • ​push_back​​​函数将元素添加到容器的末尾。当使用push_back​​​时，它会将传入的元素作为参数，首先在容器外部构造这个元素，然后将该元素复制（或移动，如果支持移动语义）到容器中。这意味着如果元素类型是类类型，这个过程可能涉及到调用拷贝构造函数或移动构造函数。
  • ​emplace_back​​​函数也是向容器末尾添加元素，但它的工作方式略有不同。emplace_back​​​会直接在容器的末尾就地构造元素，避免了额外的拷贝或移动操作。这是通过接受构造函数参数而不是元素本身，然后使用这些参数直接在容器的存储空间中构造元素来实现的。这意味着emplace_back​​​可以提供更好的性能，特别是对于复杂对象。

• iterator

  • #include <iostream>
    #include <vector>
    
    int main()
    {
    	std::vector<int> vec = { 1,2,3,4,5 };
    
    	for (auto i = vec.begin(); i != vec.end(); i++)
    	{
    		std::cout << *i << std::endl;
    	}
    	return 0;
    }
    

  • ​​

• insert(iterator position, const T& value)

  • 用途：在vector​​​​的指定位置之前插入一个新元素。
  • 语法：iterator insert(iterator position, const T& value);​​​​
  • 返回值：指向新插入元素的迭代器。

• insert(iterator position, size_type n, const T& val)

  • 用途：在指定位置插入n​​​​个val​​​​元素。
  • 语法：void insert(iterator position, size_type n, const T& val);​​​​
  • 返回值：无。

• insert( position, InputIterator first, InputIterator last)

  • 用途：在指定位置插入另一个容器[first, last)​​​​区间的所有元素。
  • 语法：void insert(iterator position, InputIterator first, InputIterator last);​​​​
  • 返回值：无。

  • #include <iostream>
    #include <vector>
    
    int main()
    {
    	std::vector<int> vec = { 1,2,3,4,5 };
    	std::vector<int> vec1 = { 11,22,33,44,55 };
    
    	//头部插入元素
    	vec.insert(vec.begin(), 0);
    
    	//尾部插入元素
    	vec.insert(vec.end(), 5, 0xCC);
    
    	//指定插入元素
    	vec.insert(vec.begin() + 2, 3);
    
    	//插入指定容器
    	vec.insert(vec.begin(), vec1.begin(), vec1.end());
    
    	return 0;
    }
    

删除函数

• pop_back()

  • 用途：删除vector​​​末尾的元素。
  • 语法：void pop_back();​​​
  • 返回值：无。

  • #include <iostream>
    #include <vector>
    
    int main()
    {
    	std::vector<int> vec = { 1,2,3,4,5 };
    	vec.pop_back();
    
    	return 0;
    }
    

  • ​​

• erase(iterator position)

  • 用途：删除vector​​​中指定位置的元素。
  • 语法：iterator erase(iterator position);​​​
  • 返回值：指向被删除元素之后元素的迭代器。

  • #include <iostream>
    #include <vector>
    
    int main()
    {
    	std::vector<int> vec = { 1,2,3,4,5 };
    	vec.erase(vec.begin() + 1);
    
    	return 0;
    }
    

  • ​​

• erase(iterator first, iterator last)

  • 用途：删除vector​​​中从first​​​到last​​​（不包括last​​​）区间内的所有元素。
  • 语法：iterator erase(iterator first, iterator last);​​​
  • 返回值：指向last​​​元素之前被删除的第一个元素之后元素的迭代器。

  • #include <iostream>
    #include <vector>
    
    int main()
    {
    	std::vector<int> vec = { 1,2,3,4,5 };
    	vec.erase(vec.begin() + 1, vec.end());
    
    	return 0;
    }
    

  • ​​

• clear()

  • 用途：删除vector​​​中的所有元素，但不改变其容量。
  • 语法：void clear();​​​
  • 返回值：无。

  • #include <iostream>
    #include <vector>
    
    int main()
    {
    	std::vector<int> vec = { 1,2,3,4,5 };
    	vec.clear();
    
    	return 0;
    }
    

修改函数

• 使用下标操作符[]

  • 用法：通过元素的索引来访问并修改vector​​​中的元素。
  • 语法：vector[index] = newValue;​​​
  • 返回值：无。

  • #include <iostream>
    #include <vector>
    
    int main()
    {
    	std::vector<int> vec = { 1,2,3,4,5 };
    
    	vec[1] = 22;
    
    	for (auto i : vec)
    	{
    		std::cout << i << std::endl;
    	}
    
    	return 0;
    }
    

• 使用at()​​成员函数

  • 用法：通过元素的索引来访问并修改vector​​​中的元素，同时进行边界检查。
  • 语法：vector.at(index) = newValue;​​​
  • 返回值：引用到指定元素的引用。

  • #include <iostream>
    #include <vector>
    
    int main()
    {
    	std::vector<int> vec = { 1,2,3,4,5 };
    
    	vec.at(2) = 222;
    
    	for (auto i : vec)
    	{
    		std::cout << i << std::endl;
    	}
    
    	return 0;
    }
    

• 使用迭代器

  • 用法：通过迭代器来访问并修改vector​​​中的元素。
  • 语法：*iterator = newValue;​​​
  • 返回值：无。

  • #include <iostream>
    #include <vector>
    
    int main()
    {
    	std::vector<int> vec = { 1,2,3,4,5 };
    
    	auto iter = vec.begin() + 3;
    	*iter = 333;
    
    	for (auto i : vec)
    	{
    		std::cout << i << std::endl;
    	}
    
    	return 0;
    }
    

• 使用front()​​和back()​​成员函数

  • 用法：修改vector​​​中的第一个元素或最后一个元素的值。

  • 语法：

    • ​vector.front() = newValue;​​​ 修改第一个元素的值。
    • ​vector.back() = newValue;​​​ 修改最后一个元素的值。

  • 返回值：分别是第一个元素和最后一个元素的引用。

  • #include <iostream>
    #include <vector>
    
    int main()
    {
    	std::vector<int> vec = { 1,2,3,4,5 };
    
    	vec.front() = 111;
    	vec.back() = 555;
    
    	for (auto i : vec)
    	{
    		std::cout << i << std::endl;
    	}
    
    	return 0;
    }
    

查找函数

• std::find

  • 用途：用于在给定的范围内查找一个特定的值。

  • 语法：std::find(Iterator first, Iterator last, const T& value);​​

    • ​first​​和last​​是定义查找范围的迭代器。
    • ​value​​是要查找的值。

  • 返回值：如果找到，则返回一个指向首次出现该值的迭代器；如果未找到，则返回last​​（结束迭代器）。

  • #include <iostream>
    #include <vector>
    
    int main()
    {
    	std::vector<int> vec = { 2,4,5,6,8 };
    
    	auto iter = std::find(vec.begin(), vec.end(), 6);
    	if (iter != vec.end())
    	{
    		std::cout << *iter << std::endl;
    	}
    
    	return 0;
    }
    

• std::find_if

  • 用途：根据一个谓词查找范围内的第一个满足条件的元素。

  • 语法：std::find_if(Iterator first, Iterator last, UnaryPredicate pred);​​

    • ​first​​和last​​是定义查找范围的迭代器。

    • ​pred​​是一个一元谓词，用于测试每个元素是否满足条件。

      • 在C++中，谓词（Predicate）是指一个函数或者函数对象（包括lambda表达式），它接收一定的输入并返回一个布尔值。这个布尔值通常用于表示某个条件是否满足。
      • 一元谓词是一种只接受一个参数的函数或函数对象。
      • 二元谓词则接受两个参数。它通常用于比较这两个参数之间的关系，比如在排序算法中定义排序准则。

  • 返回值：如果找到，则返回一个指向首次满足条件的元素的迭代器；如果未找到，则返回last​​。

  • #include <iostream>
    #include <vector>
    
    bool isNum(int x)
    {
    	return x % 2 != 0;
    }
    
    int main()
    {
    	std::vector<int> vec = { 2,4,5,6,8 };
    
    	auto iter = std::find_if(vec.begin(), vec.end(), isNum);
    	if (iter != vec.end())
    	{
    		std::cout << *iter << std::endl;
    	}
    
    	return 0;
    }