vector容器的相关操作和string非常相似.

构造函数

default (1)

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

fill (2)

 explicit vector (size_type n);
  vector (size_type n, const value_type& val,
          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 (const vector& x, const allocator_type& alloc);

move (5)

 vector (vector&& x);
 vector (vector&& x, const allocator_type& alloc);

initializer list (6)

 vector (initializer_list<value_type> il,
  const allocator_type& alloc = allocator_type());

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// constructing vectors
#include <iostream>
#include <vector>

int main ()
{
  // constructors used in the same order as described above:
  std::vector<int> first;                                // empty vector of ints
  std::vector<int> second (4,100);                       // four ints with value 100
  std::vector<int> third (second.begin(),second.end());  // iterating through second
  std::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;
}

赋值运算符

copy (1)
```
 vector& operator= (const vector& x);
```
move (2)
```
 vector& operator= (vector&& x);
```

initializer list (3)

 vector& operator= (initializer_list<value_type> il);

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> foo (3,0);
  std::vector<int> bar (5,0);

  bar = foo;
  foo = std::vector<int>();

  std::cout << "Size of foo: " << int(foo.size()) << '\n';
  std::cout << "Size of bar: " << int(bar.size()) << '\n';
  return 0;
}

迭代器

容量

元素访问

data函数

value_type* data() noexcept;
const value_type* data() const noexcept;

返回一个指向内存数组的直接指针，该指针由向量内部使用以存储其所拥有的元素。

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


// vector::data
#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> myvector (5);

  int* p = myvector.data();

  *p = 10;
  ++p;
  *p = 20;
  p[2] = 100;

  std::cout << "myvector contains:";
  for (unsigned i=0; i<myvector.size(); ++i)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';

  return 0;
}

修改

##erase函数

iterator erase (const_iterator position);
iterator erase (const_iterator first, const_iterator last);

指向由函数调用erase的最后一个元素后面的元素的新位置的迭代器。

如果操作擦除了序列中的最后一个元素，则这是容器结束。

clear函数

void clear() noexcept;

从vector中删除所有元素（被破坏），使容器的大小为0。

重新分配不能保证发生，由于调用此功能，vector capacity不能保证改变。强制重新分配的典型替代方法是使用交换：

vector<T>().swap(x);   // clear x reallocating

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> myvector;
  myvector.push_back (100);
  myvector.push_back (200);
  myvector.push_back (300);

  std::cout << "myvector contains:";
  for (unsigned i=0; i<myvector.size(); i++)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';

  myvector.clear();
  myvector.push_back (1101);
  myvector.push_back (2202);

  std::cout << "myvector contains:";
  for (unsigned i=0; i<myvector.size(); i++)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';

  return 0;
}

emplace函数

template <class... Args>
iterator emplace (const_iterator position, Args&&... args);

构造和插入元素

通过在位置插入一个新元素来扩展容器。这个新元素是使用args作为构造的参数来构建的。

这有效地将容器尺寸增加了一个。分配的存储空间的自动重新分配只有在新的vector大小超过当前的向量容量发生.

因为vector使用数组作为其底层存储，所以将元素插入到vector两端以外的位置时，会导致容器将所有位置之后的元素移位到新的位置。与其他类型的序列容器（例如list或forward_list）执行的操作相比，这通常是一个低效的操作。

元素通过使用转发的args调用allocator_traits :: construct来就地构建。

存在类似的成员函数insert，它将现有对象复制或移动到容器中。请参阅emplace_back一个成员函数，直接在最后扩展容器。元素通过使用转发的args调用allocator_traits :: construct来就地构建。存在类似的成员函数insert，它将现有对象复制或移动到容器中。

它们俩的区别在于新元素的构造上。emplace 使用直接构造，insert 使用复制构造

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> myvector = {10,20,30};

  auto it = myvector.emplace ( myvector.begin()+1, 100 );
  myvector.emplace ( it, 200 );
  myvector.emplace ( myvector.end(), 300 );

  std::cout << "myvector contains:";
  for (auto& x: myvector)
    std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

emplace_back函数

template <class... Args>
void emplace_back (Args&&... args);

在向量的末尾插入一个新的元素，就在其最后一个元素之后。这个新元素是使用args作为构造函数的参数构建的。

元素通过使用转发的args调用allocator_traits :: construct来就地构建。存在类似的成员函数push_back，它将现有对象复制或移动到容器中。

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> myvector = {10,20,30};

  myvector.emplace_back (100);
  myvector.emplace_back (200);

  std::cout << "myvector contains:";
  for (auto& x: myvector)
    std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

分配器

重载

relational operators

(1)

	template <class T, class Alloc>
	  bool operator== (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);

(2)

	template <class T, class Alloc>
	  bool operator!= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);

(3)

	template <class T, class Alloc>
	  bool operator<  (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);

(4)

	template <class T, class Alloc>
	  bool operator<= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);

(5)

	template <class T, class Alloc>
	  bool operator>  (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);

(6)

	template <class T, class Alloc>
	  bool operator>= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> foo (3,100);   // three ints with a value of 100
  std::vector<int> bar (2,200);   // two ints with a value of 200

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

  return 0;
}

swap函数

template <class T, class Alloc>
  void swap (vector<T,Alloc>& x, vector<T,Alloc>& y);

容器x的内容与y的内容交换。两个容器对象必须具有相同的类型（相同的模板参数），尽管大小可能不同。

调用该成员函数后，所有迭代器，引用和指针对交换对象仍然有效。

这是通用算法交换的重载，通过将其元素的所有权相互转移到另一个容器来提高其性能（即，容器交换对其数据的引用，而不实际执行任何元素复制或移动）

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// swap (vector overload)
#include <iostream>
#include <vector>

main ()
{
  unsigned int i;
  std::vector<int> foo (3,100);   // three ints with a value of 100
  std::vector<int> bar (5,200);   // five ints with a value of 200

  foo.swap(bar);

  std::cout << "foo contains:";
  for (std::vector<int>::iterator it = foo.begin(); it!=foo.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  std::cout << "bar contains:";
  for (std::vector<int>::iterator it = bar.begin(); it!=bar.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

vector操作总结

文章目录