C++ vector类

目录

0.前言

1.vector介绍

2.vector使用

2.1 构造函数(Constructor)

2.1.1. 默认构造函数 (Default Constructor)

2.1.2 填充构造函数 (Fill Constructor)

2.1.3 范围构造函数 (Range Constructor)

2.1.4 拷贝构造函数 (Copy Constructor)

2.2 迭代器(Iterator)

2.2.1 begin 和 end

2.2.2 rbegin 和 rend

2.3 容量控制函数(Capacity)

2.3.1 size

2.3.2 resize

2.3.3 capacity

2.3.4 empty

2.3.5 reserve

2.4 元素访问函数(Element access)

2.4.1 operator[]

2.4.2 at

2.5 修改函数(Modifiers)

2.5.1 assign

2.5.2 push_back

2.5.3 pop_back

2.5.4 insert

2.5.5 erase

2.5.6 swap

2.5.7 clear

3.vector的模拟实现

3.1 基本实现代码

3.2 疑难点分析

3.2.1 用initializer_list构造函数

3.2.2 memcpy的浅拷贝问题

3.2.3 迭代器区间构造函数与int冲突问题

4.小结


(图像由AI生成) 

0.前言

在前面的博客中,我们介绍了string类的使用与模拟实现,深入探讨了其在C++编程中的重要性和具体应用。然而,string类仅仅是C++标准模板库(STL)中的一个组成部分。为了更全面地了解STL的强大功能,本篇博客将聚焦于另一个核心容器类——vectorvector类在现代C++编程中扮演着至关重要的角色,其灵活的动态数组特性、丰富的成员函数以及高效的内存管理,使其成为开发者处理可变大小数组的首选工具。本文将详细介绍vector类的基本概念、使用方法、内部实现以及常见问题的解决方案,帮助读者全面掌握这一重要的容器类。

1.vector介绍

(本部分内容参考:vector - C++ Reference (cplusplus.com))

vector是C++标准模板库(STL)中的一个序列容器,表示可以动态改变大小的数组。

与数组类似,vector使用连续的存储位置来存储其元素,这意味着可以使用常规指针的偏移量来高效地访问其元素。不同于数组,vector的大小可以动态改变,其存储空间由容器自动管理。

内部工作原理

内部来说,vector使用一个动态分配的数组来存储其元素。当插入新元素时,这个数组可能需要重新分配以增加大小,这涉及到分配一个新的数组并将所有元素移动到新数组中。这是一个相对耗时的操作,因此vector不会在每次添加元素时都重新分配内存。

为了高效管理存储,vector容器可能会预先分配一些额外的存储空间,以应对可能的增长。因此,容器的实际容量可能大于严格存储其元素所需的容量(即其大小)。库可以实现不同的增长策略,以在内存使用和重新分配之间取得平衡,但无论如何,重新分配应仅在容量按对数增长的间隔时发生,从而确保在vector末尾插入单个元素的操作可以提供摊销常数时间复杂度。

因此,与数组相比,vector消耗更多内存以换取能够高效地管理存储和动态增长的能力。

与其他动态序列容器的比较

与其他动态序列容器(如dequelistforward_list)相比,vector在访问其元素方面非常高效(就像数组一样),在从末尾添加或删除元素方面也相对高效。对于涉及在末尾以外的位置插入或删除元素的操作,vector的性能不如其他容器,并且其迭代器和引用的稳定性也不如listforward_list

容器属性

  • 序列容器:序列容器中的元素按照严格的线性序列排序。可以通过其在序列中的位置访问单个元素。
  • 动态数组:允许直接访问序列中的任何元素,甚至通过指针算术操作,并且提供了相对快速的在序列末尾添加/移除元素的功能。
  • 分配器感知:容器使用一个分配器对象来动态处理其存储需求。

2.vector使用

2.1 构造函数(Constructor)

default (1)
explicit vector (const allocator_type& alloc = allocator_type());
fill (2)
explicit vector (size_type n, const value_type& val = value_type(),const allocator_type& alloc = allocator_type());
range (3)
template <class InputIterator>vector (InputIterator first, InputIterator last,const allocator_type& alloc = allocator_type());
copy (4)
vector (const vector& x);

vector类提供了多种构造函数,以便在不同的场景中灵活地创建vector对象。以下是几种主要的构造函数及其使用方法:

2.1.1. 默认构造函数 (Default Constructor)

explicit vector (const allocator_type& alloc = allocator_type());

这个构造函数创建一个空的vector,可以选择性地指定一个内存分配器。

示例代码:

std::vector<int> first; // 创建一个空的int类型vector

2.1.2 填充构造函数 (Fill Constructor)

explicit vector (size_type n, const value_type& val = value_type(),const allocator_type& alloc = allocator_type());

这个构造函数创建一个包含n个元素的vector,每个元素的初始值为val,并可以选择性地指定一个内存分配器。

示例代码:

std::vector<int> second(4, 100); // 创建一个包含4个元素的vector,每个元素的值为100

2.1.3 范围构造函数 (Range Constructor)

template <class InputIterator>
vector (InputIterator first, InputIterator last,const allocator_type& alloc = allocator_type());

这个构造函数使用迭代器区间[first, last)的元素创建一个vector,并可以选择性地指定一个内存分配器。

示例代码:

std::vector<int> third(second.begin(), second.end()); // 使用second的迭代器区间创建vector

2.1.4 拷贝构造函数 (Copy Constructor)

vector (const vector& x);

这个构造函数创建一个与x相同的vector

示例代码:

std::vector<int> fourth(third); // 使用third创建一个新的vector副本

下面是一个完整的示例代码,展示了上述几种构造函数的使用方法:

// constructing vectors
#include <iostream>
#include <vector>int main ()
{// constructors used in the same order as described above:std::vector<int> first;                                // empty vector of intsstd::vector<int> second (4,100);                       // four ints with value 100std::vector<int> third (second.begin(),second.end());  // iterating through secondstd::vector<int> fourth (third);                       // a copy of third// the iterator constructor can also be used to construct from arrays:int myints[] = {16,2,77,29};std::vector<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );std::cout << "The contents of fifth are:";for (std::vector<int>::iterator it = fifth.begin(); it != fifth.end(); ++it)std::cout << ' ' << *it;std::cout << '\n';return 0;
}

代码解释:

  • first是一个空的vector,使用默认构造函数创建。
  • second是一个包含4个元素的vector,每个元素的值为100,使用填充构造函数创建。
  • third是通过遍历second的所有元素创建的vector,使用范围构造函数创建。
  • fourththird的副本,使用拷贝构造函数创建。
  • fifth是通过从数组myints中复制元素创建的vector,同样使用范围构造函数。

2.2 迭代器(Iterator)

迭代器是一个重要的工具,使我们能够遍历和操作容器中的元素。vector类提供了多种迭代器,以便在不同的场景中灵活地操作元素。以下是几种主要的迭代器及其使用方法:

2.2.1 beginend

  • begin:返回指向vector第一个元素的迭代器。如果vector是空的,这个迭代器等于end
  • end:返回指向vector末尾元素之后一个位置的迭代器。这个位置不包含在vector中,因此不能被解引用。

示例代码:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector = {1, 2, 3, 4, 5};std::cout << "Vector elements: ";for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)std::cout << ' ' << *it;std::cout << '\n';return 0;
}

在这个示例中,beginend迭代器用于遍历vector中的所有元素,并输出它们的值。

2.2.2 rbeginrend

  • rbegin:返回指向vector最后一个元素的反向迭代器。反向迭代器允许我们从vector的末尾向前遍历。
  • rend:返回指向vector第一个元素之前一个位置的反向迭代器。这使得我们可以使用反向迭代器来访问vector中的元素。

示例代码:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector = {1, 2, 3, 4, 5};std::cout << "Vector elements in reverse order: ";for (std::vector<int>::reverse_iterator rit = myvector.rbegin(); rit != myvector.rend(); ++rit)std::cout << ' ' << *rit;std::cout << '\n';return 0;
}

在这个示例中,rbeginrend反向迭代器用于反向遍历vector中的所有元素,并输出它们的值。

2.3 容量控制函数(Capacity)

vector类提供了一些函数用于管理和控制容器的容量和大小。这些函数能够帮助我们在处理动态数组时更加高效和灵活。以下是主要的容量控制函数及其使用方法:

2.3.1 size

size函数返回当前vector中元素的数量。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector = {1, 2, 3, 4, 5};std::cout << "The size of myvector is: " << myvector.size() << '\n';return 0;
}

在这个示例中,size函数返回vector中的元素数量,即5。

2.3.2 resize

resize函数改变vector的大小。如果新的大小大于当前大小,则添加默认值元素;如果新的大小小于当前大小,则移除多余的元素。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector = {1, 2, 3, 4, 5};myvector.resize(3); // 将大小调整为3,移除多余元素std::cout << "After resize to 3, myvector contains:";for (int n : myvector) std::cout << ' ' << n;std::cout << '\n';myvector.resize(5, 100); // 将大小调整为5,新增元素值为100std::cout << "After resize to 5 with default value 100, myvector contains:";for (int n : myvector) std::cout << ' ' << n;std::cout << '\n';return 0;
}

代码解释:

  • 第一次调用resizevector的大小从5调整为3,移除了多余的元素。
  • 第二次调用resizevector的大小调整为5,新增的两个元素值为100。

2.3.3 capacity

capacity函数返回vector分配的存储容量,即vector可以存储多少元素而不需要重新分配内存。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector;myvector.reserve(10); // 预留容量std::cout << "The capacity of myvector is: " << myvector.capacity() << '\n';return 0;
}

在这个示例中,reserve函数预留了10个元素的容量,然后capacity函数返回vector当前的容量。

2.3.4 empty

empty函数检查vector是否为空。如果vector不包含任何元素,则返回true;否则返回false

使用示例:

#include <vector>int main() {std::vector<int> myvector;if (myvector.empty()) {std::cout << "myvector is empty.\n";} else {std::cout << "myvector is not empty.\n";}myvector.push_back(1);if (myvector.empty()) {std::cout << "myvector is empty.\n";} else {std::cout << "myvector is not empty.\n";}return 0;
}

代码解释:

  • 初始时,myvector是空的,因此empty函数返回true
  • 在向vector添加一个元素后,empty函数返回false

2.3.5 reserve

reserve函数请求分配至少能够存储指定数量元素的内存容量。如果指定容量小于当前容量,则不会改变vector的容量。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector;myvector.reserve(10); // 请求分配容量std::cout << "Capacity after reserve(10): " << myvector.capacity() << '\n';myvector.push_back(1);std::cout << "Capacity after push_back: " << myvector.capacity() << '\n';return 0;
}

代码解释:

  • reserve(10)请求分配至少10个元素的内存容量。
  • 调用push_back函数向vector添加一个元素后,容量保持不变,因为vector已经有足够的空间来存储新元素。

2.4 元素访问函数(Element access)

vector类提供了一些函数用于访问和操作存储在容器中的元素。以下是主要的元素访问函数及其使用方法:

2.4.1 operator[]

operator[]是一个重载的下标操作符,用于访问指定位置的元素。该操作符不进行边界检查,因此如果访问越界,将导致未定义行为。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector = {10, 20, 30, 40, 50};std::cout << "Element at index 2 is: " << myvector[2] << '\n';  // 输出 30myvector[2] = 100;  // 修改元素值std::cout << "Element at index 2 after modification is: " << myvector[2] << '\n';  // 输出 100return 0;
}

代码解释:

  • 使用myvector[2]访问并输出索引为2的元素(初始值为30)。
  • 通过myvector[2] = 100修改索引为2的元素值。
  • 再次访问并输出修改后的元素值(新值为100)。

2.4.2 at

at函数用于访问指定位置的元素,与operator[]不同的是,at会进行边界检查。如果指定的位置超出范围,将抛出一个out_of_range异常。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector = {10, 20, 30, 40, 50};try {std::cout << "Element at index 2 is: " << myvector.at(2) << '\n';  // 输出 30myvector.at(2) = 100;  // 修改元素值std::cout << "Element at index 2 after modification is: " << myvector.at(2) << '\n';  // 输出 100// 尝试访问超出范围的元素std::cout << "Element at index 10 is: " << myvector.at(10) << '\n';} catch (const std::out_of_range& e) {std::cerr << "Out of range error: " << e.what() << '\n';}return 0;
}

代码解释:

  • 使用myvector.at(2)访问并输出索引为2的元素(初始值为30)。
  • 通过myvector.at(2) = 100修改索引为2的元素值。
  • 再次访问并输出修改后的元素值(新值为100)。
  • 尝试访问超出范围的元素myvector.at(10)时,捕获并处理out_of_range异常,输出错误信息。

2.5 修改函数(Modifiers)

vector类提供了多种修改其内容的方法。以下是主要的修改函数及其使用方法:

2.5.1 assign

assign函数用于为vector分配新内容,替换其当前内容并调整其大小。它有多个重载版本,可以接受不同类型的输入参数。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector;// 使用 count 和 value 版本的 assignmyvector.assign(7, 100);  // 7 个值为 100 的元素std::cout << "myvector contains:";for (int i : myvector)std::cout << ' ' << i;std::cout << '\n';// 使用迭代器区间版本的 assignstd::vector<int> anothervector = {1, 2, 3, 4, 5};myvector.assign(anothervector.begin(), anothervector.end());std::cout << "myvector now contains:";for (int i : myvector)std::cout << ' ' << i;std::cout << '\n';return 0;
}

代码解释:

  • 第一次调用assign使用7个值为100的元素替换vector内容。
  • 第二次调用assign使用另一个vector的元素替换vector内容。

2.5.2 push_back

push_back函数在vector的末尾添加一个元素。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector;myvector.push_back(10);myvector.push_back(20);myvector.push_back(30);std::cout << "myvector contains:";for (int i : myvector)std::cout << ' ' << i;std::cout << '\n';return 0;
}

代码解释:

  • 依次向vector的末尾添加10、20和30。

2.5.3 pop_back

pop_back函数删除vector末尾的元素。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector = {10, 20, 30};myvector.pop_back();std::cout << "myvector contains:";for (int i : myvector)std::cout << ' ' << i;std::cout << '\n';return 0;
}

代码解释:

  • 删除vector末尾的元素(30)。

2.5.4 insert

insert函数用于在指定位置插入元素,有多个重载版本,支持插入单个元素、多个元素或一个迭代器区间的元素。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector = {10, 20, 30};// 插入单个元素myvector.insert(myvector.begin(), 5);// 插入多个相同元素myvector.insert(myvector.end(), 2, 100);// 插入另一个 vector 的元素std::vector<int> anothervector = {1, 2, 3};myvector.insert(myvector.begin() + 1, anothervector.begin(), anothervector.end());std::cout << "myvector contains:";for (int i : myvector)std::cout << ' ' << i;std::cout << '\n';return 0;
}

代码解释:

  • vector开头插入单个元素5。
  • vector末尾插入两个值为100的元素。
  • vector第二个位置插入另一个vector的元素。

2.5.5 erase

erase函数用于删除指定位置的元素或一个元素区间。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector = {10, 20, 30, 40, 50};// 删除单个元素myvector.erase(myvector.begin() + 1);  // 删除第二个元素// 删除一个区间的元素myvector.erase(myvector.begin(), myvector.begin() + 2);  // 删除前两个元素std::cout << "myvector contains:";for (int i : myvector)std::cout << ' ' << i;std::cout << '\n';return 0;
}

代码解释:

  • 删除vector中第二个元素(20)。
  • 删除vector中前两个元素(10和30)。

2.5.6 swap

swap函数用于交换两个vector的内容。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> first = {1, 2, 3};std::vector<int> second = {4, 5, 6, 7};first.swap(second);std::cout << "first contains:";for (int i : first)std::cout << ' ' << i;std::cout << '\n';std::cout << "second contains:";for (int i : second)std::cout << ' ' << i;std::cout << '\n';return 0;
}

代码解释:

  • 交换firstsecond的内容。

2.5.7 clear

clear函数用于清空vector的所有元素。

使用示例:

#include <iostream>
#include <vector>int main() {std::vector<int> myvector = {10, 20, 30};myvector.clear();std::cout << "myvector contains " << myvector.size() << " elements.\n";return 0;
}

代码解释:

  • 清空vector的所有元素,size将为0。

3.vector的模拟实现

3.1 基本实现代码

template <class T>
class vector
{
public:typedef T* iterator;typedef const T* const_iterator;typedef T& reference;typedef const T& const_reference;
private:iterator _start;iterator _finish;iterator _end_of_storage;
public:iterator begin(){return _start;}iterator end(){return _finish;}const_iterator cbegin() const{return _start;}const_iterator cend() const{return _finish;}// 默认构造函数vector(){_start = nullptr;_finish = nullptr;_end_of_storage = nullptr;}// 带初始大小和初始值的构造函数vector(size_t n, const T& val = T()){_start = new T[n];for (size_t i = 0; i < n; i++){_start[i] = val;}_finish = _start + n;_end_of_storage = _start + n;}// 带整数大小和初始值的构造函数vector(int n, const T& val = T()){_start = new T[n];for (size_t i = 0; i < n; i++){_start[i] = val;}_finish = _start + n;_end_of_storage = _start + n;}// 拷贝构造函数vector(const vector<T>& v){_start = new T[v.capacity()];for (size_t i = 0; i < v.size(); i++){_start[i] = v._start[i];}_finish = _start + v.size();_end_of_storage = _start + v.capacity();}// 区间构造函数template<class InputIterator>vector(InputIterator first, InputIterator last){size_t n = last - first;_start = new T[n];for (size_t i = 0; i < n; i++){_start[i] = *first;++first;}_finish = _start + n;_end_of_storage = _start + n;}// 初始化列表构造函数vector(std::initializer_list<T> l){size_t n = l.size();_start = new T[n];auto it = l.begin();for (size_t i = 0; i < n; i++){_start[i] = *it;it++;}_finish = _start + n;_end_of_storage = _start + n;}// 赋值运算符vector<T>& operator=(const vector<T>& v){if (this != &v){T* tmp = new T[v.capacity()];for (size_t i = 0; i < v.size(); i++){tmp[i] = v._start[i];}delete[] _start;_start = tmp;_finish = _start + v.size();_end_of_storage = _start + v.capacity();}return *this;}// 析构函数~vector(){if (_start){delete[] _start;_start = _finish = _end_of_storage = nullptr;}}// 返回元素个数size_t size() const{return _finish - _start;}// 返回容量size_t capacity() const{return _end_of_storage - _start;}// 预留空间void reserve(size_t n){if (n > capacity()){size_t size = this->size();T* tmp = new T[n];if (_start){for (size_t i = 0; i < size; i++){tmp[i] = _start[i];}delete[] _start;}_start = tmp;_finish = _start + size;_end_of_storage = _start + n;}}// 调整大小void resize(size_t n, const T& val = T()){if (n < size()){_finish = _start + n;}else if (n > size()){if (n > capacity()){reserve(n);}for (size_t i = size(); i < n; i++){_start[i] = val;}_finish = _start + n;}}// 检查是否为空bool empty() const{return _start == _finish;}// 下标操作符reference operator[](size_t pos){assert(pos < size());return _start[pos];}const_reference operator[](size_t pos) const{assert(pos < size());return _start[pos];}// 返回第一个元素的引用reference front(){return *_start;}const_reference front() const{return *_start;}// 返回最后一个元素的引用reference back(){return *(_finish - 1);}const_reference back() const{return *(_finish - 1);}// 在末尾添加元素void push_back(const T& x){if (_finish == _end_of_storage){size_t n = capacity() == 0 ? 1 : 2 * capacity();reserve(n);}*_finish = x;++_finish;}// 删除末尾元素void pop_back(){assert(_start < _finish);--_finish;}// 插入元素iterator insert(iterator pos, const T& x){assert(pos >= _start && pos <= _finish);if (_finish == _end_of_storage){size_t n = pos - _start;size_t newcapacity = capacity() == 0 ? 1 : 2 * capacity();reserve(newcapacity);pos = _start + n;}iterator end = _finish;while (end > pos){*end = *(end - 1);--end;}*pos = x;++_finish;return pos;}// 删除指定位置的元素iterator erase(iterator pos){assert(pos >= _start && pos < _finish);iterator begin = pos + 1;while (begin < _finish){*(begin - 1) = *begin;++begin;}--_finish;return pos;}// 删除区间元素iterator erase(iterator first, iterator last){assert(first >= _start && last <= _finish && first <= last);iterator begin = last;while (begin < _finish){*(first) = *begin;++first;++begin;}_finish = first;return first;}// 交换内容void swap(vector<T>& v){std::swap(_start, v._start);std::swap(_finish, v._finish);std::swap(_end_of_storage, v._end_of_storage);}// 清空内容void clear(){_finish = _start;}
};

3.2 疑难点分析

3.2.1 用initializer_list构造函数

在C++11中,引入了一种新的类型std::initializer_list,它允许我们使用初始化列表的方式来初始化容器和对象。initializer_list提供了一种简单的语法,用于在构造对象时直接列出其元素,例如在构造vector对象时可以像这样:vector<int> v = {1, 2, 3, 4, 5};

std::initializer_list类型提供了一些基本的成员函数,例如size()可以返回列表中元素的数量,begin()end()则分别返回指向列表开头和末尾的迭代器。

下面是一个实现initializer_list构造函数的示例:

// 初始化列表构造函数
vector(std::initializer_list<T> l)
{size_t n = l.size();_start = new T[n];  // 分配足够的内存来存储初始化列表中的元素auto it = l.begin();for (size_t i = 0; i < n; i++){_start[i] = *it;  // 将初始化列表中的元素逐个复制到_vector_中it++;}_finish = _start + n;  // 设置_finish_指向最后一个元素的下一个位置_end_of_storage = _start + n;  // 设置_end_of_storage_指向分配的内存末尾
}

在这个构造函数中:

  1. size_t n = l.size();:首先获取初始化列表的大小,即需要存储的元素数量。
  2. _start = new T[n];:分配一个大小为n的数组,作为vector的存储空间。
  3. auto it = l.begin();:获取初始化列表的起始迭代器。
  4. for (size_t i = 0; i < n; i++) { _start[i] = *it; it++; }:使用循环将初始化列表中的元素逐个复制到vector中。迭代器it从初始化列表的开头开始,依次访问每个元素,并将其赋值到_start数组中对应的位置。
  5. _finish = _start + n;:设置_finish指向最后一个元素的下一个位置,这样可以表示当前vector的实际大小。
  6. _end_of_storage = _start + n;:设置_end_of_storage指向分配的内存末尾,表示当前vector的容量。

通过这种方式,我们可以使用初始化列表来方便地构造vector对象,使代码更加简洁和直观。

3.2.2 memcpy的浅拷贝问题

在实现vectorreserve函数时,如果我们直接使用memcpy来拷贝内存,而不是逐个元素复制,会引发一些问题,尤其是当vector的元素类型是std::string或其他复杂类型时。为了更好地理解这个问题,我们首先需要了解memcpy和逐个元素复制的区别。

memcpy与逐个元素复制的区别

memcpy是一种高效的内存拷贝方法,用于复制原始字节流。但是,它只是简单地将内存块从一个位置复制到另一个位置,而不考虑元素的构造和析构。这意味着,对于像std::string这样具有内部动态内存管理和析构函数的类型,memcpy不会正确地处理这些类型的内部资源。

相反,逐个元素复制(例如使用赋值运算符或拷贝构造函数)会确保每个元素的正确构造和析构。对于std::string等复杂类型,这种方法会确保其内部资源(如动态分配的内存)被正确管理。

reserve函数的实现

vectorreserve函数中,我们需要为新的容量分配内存,并将现有元素复制到新分配的内存中。下面是一个正确实现的示例:

template <class T>
class vector
{// ... other members and functions ...// 预留空间void reserve(size_t n){if (n > capacity()){size_t size = this->size();T* tmp = new T[n];if (_start){for (size_t i = 0; i < size; i++){tmp[i] = _start[i]; // 逐个元素复制}delete[] _start;}_start = tmp;_finish = _start + size;_end_of_storage = _start + n;}}// ... other members and functions ...
};

但是,如果我们使用memcpy来拷贝内存,例如:

#include <cstring> // for std::memcpyvoid reserve(size_t n)
{if (n > capacity()){size_t size = this->size();T* tmp = new T[n];if (_start){std::memcpy(tmp, _start, size * sizeof(T)); // 使用memcpy来拷贝内存delete[] _start;}_start = tmp;_finish = _start + size;_end_of_storage = _start + n;}
}

这种实现对于std::string等复杂类型会产生问题,因为memcpy只是简单地复制内存,而不会调用这些类型的拷贝构造函数。这可能导致:

  1. 浅拷贝问题:对于std::stringmemcpy只会复制指向内部字符数组的指针,而不会复制字符数组本身。这会导致多个std::string对象共享同一块内存,当其中一个对象被修改或销毁时,可能会影响其他对象,导致未定义行为。

  2. 资源泄漏:如果源对象拥有动态分配的资源(如std::string的内部字符数组),使用memcpy进行复制后,新的对象不会拥有这些资源的所有权,可能会导致资源泄漏或重复释放。

  3. 破坏对象的状态:一些类型可能在对象构造和析构时进行状态管理,memcpy不会调用这些类型的构造和析构函数,从而破坏对象的状态。

因此,对于需要正确管理资源的复杂类型,应该避免使用memcpy来进行内存拷贝,而应使用逐个元素复制的方法,以确保每个元素的构造和析构函数被正确调用。这样可以避免潜在的浅拷贝问题和资源管理问题,确保vector的正确和安全使用。

3.2.3 迭代器区间构造函数与int冲突问题

在实现vector类的构造函数时,我们可能会遇到不同构造函数之间的冲突问题。特别是当我们有一个带有初始大小和初始值的构造函数和一个接受迭代器区间的构造函数时,这种冲突尤为明显。

假设我们有如下两个构造函数:

// 带初始大小和初始值的构造函数
vector(size_t n, const T& val = T())
{_start = new T[n];for (size_t i = 0; i < n; i++){_start[i] = val;}_finish = _start + n;_end_of_storage = _start + n;
}// 区间构造函数
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{size_t n = last - first;_start = new T[n];for (size_t i = 0; i < n; i++){_start[i] = *first;++first;}_finish = _start + n;_end_of_storage = _start + n;
}

当我们调用vector<int> v(10, 10);时,编译器可能会选择调用区间构造函数而不是带初始大小和初始值的构造函数,因为int类型可以与模板参数InputIterator匹配。这会导致编译错误或意外行为。

为了解决这个问题,我们可以使用SFINAE(Substitution Failure Is Not An Error)技术,即在模板参数中添加类型检查,使得模板匹配只在特定条件下成立。这可以通过std::enable_if和类型特征(如std::is_integral)来实现。

#include <type_traits>template <class T>
class vector
{
public:typedef T* iterator;typedef const T* const_iterator;typedef T& reference;typedef const T& const_reference;private:iterator _start;iterator _finish;iterator _end_of_storage;public:// 默认构造函数vector(){_start = nullptr;_finish = nullptr;_end_of_storage = nullptr;}// 带初始大小和初始值的构造函数template<typename U = T>vector(size_t n, const T& val = T(), typename std::enable_if<std::is_integral<U>::value>::type* = 0){_start = new T[n];for (size_t i = 0; i < n; i++){_start[i] = val;}_finish = _start + n;_end_of_storage = _start + n;}// 区间构造函数template<class InputIterator>vector(InputIterator first, InputIterator last, typename std::enable_if<!std::is_integral<InputIterator>::value>::type* = 0){size_t n = last - first;_start = new T[n];for (size_t i = 0; i < n; i++){_start[i] = *first;++first;}_finish = _start + n;_end_of_storage = _start + n;}// ... 其他成员函数 ...
};

代码解释

  1. 带初始大小和初始值的构造函数

    • template<typename U = T>:使用一个默认模板参数U,默认值为T
    • typename std::enable_if<std::is_integral<U>::value>::type* = 0:仅当U是整型时,这个构造函数才有效。
  2. 区间构造函数

    • template<class InputIterator>:接受两个迭代器参数。
    • typename std::enable_if<!std::is_integral<InputIterator>::value>::type* = 0:仅当InputIterator不是整型时,这个构造函数才有效。

通过这种方式,我们可以避免带初始大小和初始值的构造函数和区间构造函数之间的冲突,确保在调用vector<int> v(10, 10);时,编译器会正确选择带初始大小和初始值的构造函数,而不会误调用区间构造函数。

4.小结

通过对C++中vector类的深入探讨,我们了解了其构造函数、迭代器、容量控制函数、元素访问函数和修改函数的具体实现和使用方法。特别是对initializer_listmemcpy浅拷贝问题的分析,及解决迭代器区间构造函数与整数类型冲突的方法,让我们对如何正确高效地使用和实现vector有了更全面的理解。希望通过本文,大家能够更好地掌握vector的用法,在实际编程中发挥其强大功能。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/web/15623.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

十、通配符和正则表达式

10.1 通配符 通配符是由shell处理的, 它只会出现在 命令的“参数”里。当shell在“参数”中遇到了通配符 时&#xff0c;shell会将其当作路径或文件名去在磁盘上搜寻可能的匹配&#xff1a;若符合要求的匹配存在&#xff0c;则进 行代换(路径扩展)&#xff1b;否则就将该通配…

Qt for android 获取USB设备列表(一)Java方式 获取

简介 QtActivity 作为 Qt 应用程序的入口点&#xff0c;负责启动和配置 Qt 应用程序的信息&#xff0c; 后面我们继承 QtActivity 做自定义控制&#xff0c;了解一下 Activity 生命周期概念&#xff0c; 因为 QtActivity 继承自Android的activity&#xff0c;使用周期函数完成我…

java8新特性——函数式编程详解

目录 一 概述1.1 背景1.2 函数式编程的意义1.3 函数式编程的发展 Lambda表达式1.1 介绍1.2 使用Lambda的好处1.3 Lambda方法1.3.1 Lambda表达式结构1.3.2 Lambda表达式的特征 1.4 Lambda的使用1.4.1 定义函数式接口1.4.2 Lambda表达式实现函数式接口1.4.3 简化Lambda表达式1.4.…

C++学习/复习4--与类相关的概念/默认成员函数/运算符重载/Date类实现案例

一、类和对象 1.本章概要 2.C中的结构体(struct与class) 升级为类 &#xff08;1&#xff09;类及成员函数的两种定义方式 声明与定义分离 &#xff08;2&#xff09;权限 注意1&#xff1a;struct/class在权限上的区别 &#xff08;3&#xff09;封装 &#xff08;4&#x…

《Ai学习笔记》自然语言处理 (Natural Language Processing):机器阅读理解-基础概念解析01

自然语言处理 (Natural Language Processing)&#xff1a; NLP四大基本任务 序列标注&#xff1a; 分词、词性标注 分类任务&#xff1a; 文本分类、情感分析 句子关系&#xff1a;问答系统、对话系统 生成任务&#xff1a;机器翻译、文章摘要 机器阅读理解的定义 Machi…

《安富莱嵌入式周报》第337期:超高性能信号量测量,协议分析的开源工具且核心算法开源,工业安全应用的双通道数字I/O模组,低成本脑机接口,开源音频合成器

周报汇总地址&#xff1a;http://www.armbbs.cn/forum.php?modforumdisplay&fid12&filtertypeid&typeid104 视频版&#xff1a; https://link.zhihu.com/?targethttps%3A//www.bilibili.com/video/BV1PT421S7TR/ 《安富莱嵌入式周报》第337期&#xff1a;超高性…

【Spring Boot】分层开发 Web 应用程序(含实例)

分层开发 Web 应用程序 1.应用程序分层开发模式&#xff1a;MVC1.1 了解 MVC 模式1.2 MVC 和三层架构的关系 2.视图技术 Thymeleaf3.使用控制器3.1 常用注解3.1.1 Controller3.1.2 RestController3.1.3 RequestMapping3.1.4 PathVariable 3.2 将 URL 映射到方法3.3 在方法中使用…

如何安装虚拟机Wmware,并且在虚拟机中使用centos系统

1. 前言 大家好&#xff0c;我是jiaoxingk 本篇文章主要讲解如何安装虚拟机&#xff0c;并且在虚拟机中安装centos系统&#xff0c;让windows电脑也能够使用Linux系统 2. 虚拟机的介绍 在安装Vmware之前&#xff0c;我们先做虚拟机的介绍 虚拟机&#xff1a;通过软件虚拟出来的…

Docker拉取镜像报错:x509: certificate has expired or is not yet v..

太久没有使用docker进行镜像拉取&#xff0c;今天使用docker-compose拉取mongo发现报错&#xff08;如下图&#xff09;&#xff1a; 报错信息翻译&#xff1a;证书已过期或尚未有效。 解决办法&#xff1a; 1.一般都是证书问题或者系统时间问题导致&#xff0c;可以先执行 da…

用HAL库改写江科大的stm32入门例子-6-2 定时器外部时钟

实验目的&#xff1a; 熟悉外部时钟的应用。 实验步骤&#xff1a; 创建项目参照前面的文章&#xff0c;集成oled(没有oled,用uart串口传递也可以)选择外部时钟源时钟源参数设置编写代码&#xff1a; 5.1声明全局变量&#xff0c;如果发生定时器中断的时候&#xff0c;在回调…

AI网络爬虫-自动获取百度实时热搜榜

工作任务和目标&#xff1a;自动获取百度实时热搜榜的标题和热搜指数 标题&#xff1a;<div class"c-single-text-ellipsis"> 东部战区台岛战巡演练模拟动画 <!--48--></div> <div class"hot-index_1Bl1a"> 4946724 </div> …

【DZ模板】价值288克米设计APP手机版DZ模板 数据本地化+完美使用

模版介绍 【DZ模板】价值288克米设计APP手机版DZ模板 数据本地化完美使用 腾讯官方出品discuz论坛DIY的后台设置&#xff0c;功能齐全&#xff0c;论坛功能不亚于葫芦侠&#xff0c;自定义马甲&#xff0c;自定义认证&#xff0c;自定义广告&#xff0c;完全可以打造出自己想…

【AI新时代】拥抱未来,用AI无人直播替代真人直播,解放劳动力,控制成本!

在科技日新月异的新时代&#xff0c;人工智能&#xff08;AI&#xff09;的 keJ0277 浪潮正在席卷各行各业&#xff0c;为传统的工作模式带来了前所未有的变革。其中&#xff0c;AI无人直播的兴起&#xff0c;无疑是这场科技革命中的一股强劲力量。它以其独特的优势&#xff0…

【Linux设备驱动】1.字符设备驱动程序框架及相关结构体

目录 程序总体框架模块加载函数模块卸载函数具体操作函数 相关结构体cdev结构体file_oparations结构体 设备号分配设备号注销设备号创建设备文件 程序总体框架 /* 包含相关头文件 */ #include <linux/module.h> #include <linux/fs.h> #include <linux/init.h&…

C++ Primer Plus第十八章复习题

1、使用用大括号括起的初始化列表语法重写下述代码。重写后的代码不应使用数组ar。 class z200 { private:int j;char ch;double z; public:Z200(int jv,char chv&#xff0c;zv) : j(jv), ch (chv), z(zv){} };double x 8.8; std::string s "what a bracing effect ! …

深入了解数据库设计中的规范化与反规范化

目录 零、前言 一、一些基本术语 二、关系模式 2.1. 什么是关系模式 2.2. 示例 三、数据依赖 3.1. 函数依赖 3.1.1. 完全函数依赖 3.1.2. 部分函数依赖 3.1.3. 传递函数依赖 3.2. 多值依赖 3.3. 连接依赖 四、规范化 4.1. 第一范式&#xff08;1NF&#xff09; …

【Flutter】有状态组件StatefulWidgetScaffold组件属性

&#x1f525; 本文由 程序喵正在路上 原创&#xff0c;CSDN首发&#xff01; &#x1f496; 系列专栏&#xff1a;Flutter学习 &#x1f320; 首发时间&#xff1a;2024年5月26日 &#x1f98b; 欢迎关注&#x1f5b1;点赞&#x1f44d;收藏&#x1f31f;留言&#x1f43e; 目…

AI菜鸟向前飞 — LangChain系列之十四 - Agent系列:从现象看机制(上篇)

上一篇介绍了Agent与LangGraph的基础技能Tool的必知必会 AI菜鸟向前飞 — LangChain系列之十三 - 关于Tool的必知必会 前面已经详细介绍了Promp、RAG&#xff0c;终于来到Agent系列&#xff08;别急后面还有LangGraph&#xff09;&#xff0c;大家可以先看下这张图&#xff1…

leetcode328. 奇偶链表,附详细解析和代码注释

leetcode328. 奇偶链表 给定单链表的头节点 head &#xff0c;将所有索引为奇数的节点和索引为偶数的节点分别组合在一起&#xff0c;然后返回重新排序的列表。 第一个节点的索引被认为是 奇数 &#xff0c; 第二个节点的索引为 偶数 &#xff0c;以此类推。 请注意&#xff0…