vector向量类使用

向量是最简单的 STL 容器，其数据结构与数组相似，占据着一个连续的内存块。

   由于内存位置是连续的，所以向量中的元素可以随机访问，访问向量中任何一个元素的时间也是固定的。
   存储空间的管理是自动的，当要将一个元素插入到已满的向量中时，会为向量分配一个更大的内存块，将
   向量中的元素复制进新的内存块中，然后释放旧的内存块。所以，向量是一个灵活的数组，是能够
   动态改变自身大小的数组。
  #include 
  #include // 为了使用向量类
  #include 
  #include  // greater

  using namespace std;

  // 通用打印 向量类vector的 元素 
  template
  void printVector(char *s, const vector& v) {
    cout << s << " = (";
    if (v.size() == 0) {
      cout << ")\n";//输出 换行 
      return;
      }
      // 类型别名  常量迭代器  不能修改指向的对象 
  typename vector::const_iterator i = v.begin();
    for( ; i != v.end()–1; i++)// for( ; i < v.end()-1; ++i)
      cout << *i << ' ';//打印元素 

    cout << *i << ")\n";//输出最后一个元素 并 换行 
  }

  bool f1(int n) {
    return n < 4;
  }

  int main() {
  int a[] = {1,2,3,4,5};
  vector v1; // 向量v1 为空, size = 0, capacity = 0
  printVector("v1",v1);

  for (int j = 1; j <= 5; j++)
    v1.push_back(j); // v1 = (1 2 3 4 5), 大小size = 5, 当前最大存储能力 capacity = 8
  // 注意，向量没有 push_front()成员函数。


  vector v2(3,7); // v2 = (7 7 7)

  vector ::iterator i1 = v1.begin()+1;

  vector v3(i1,i1+2); // 截取赋值 v3 = (2 3), size = 2, capacity = 2

  vector v4(v1); // 拷贝赋值 v4 = (1 2 3 4 5), size = 5, capacity = 5

  vector v5(5); // v5 = (0 0 0 0 0)

  v5[1] = v5.at(3) = 9; // 指定位置赋值 v5 = (0 9 0 9 0)

  // 向量的容量 可以通过函数 reserve()来改变(尽力改变)。
  v3.reserve(6); // v3 = (2 3), size = 2, capacity = 6

  v4.resize(7); // v4 = (1 2 3 4 5 0 0), size = 7, capacity = 10
  v4.resize(3); // v4 = (1 2 3), size = 3, capacity = 10
  v4.clear(); //清空 数据但是 分配的内存为减少 v4 is empty, size = 0, capacity = 10 ！！！！ 
  // 向量的插入 
  v4.insert(v4.end(),v3[1]); // v4 = (3)
  v4.insert(v4.end(),v3.at(1)); // v4 = (3 3)
  v4.insert(v4.end(),2,4); // v4 = (3 3 4 4)
  v4.insert(v4.end(),v1.begin()+1,v1.end()-1); // v4 = (3 3 4 4 2 3 4)
  // 删除指定元素 
  v4.erase(v4.end()-2); // v4 = (3 3 4 4 2 4)
  v4.erase(v4.begin(), v4.begin()+4); // v4 = (2 4)

  // assign替换 先删除原有元素，在插入元素 
  v4.assign(3,8); // v4 = (8 8 8)
  v4.assign(a,a+3); // v4 = (1 2 3)

  // 逆 迭代器 从尾部向前 迭代 
  vector::reverse_iterator i3 = v4.rbegin();
  for ( ; i3 != v4.rend(); i3++)
  cout << *i3 << ' '; // print: 3 2 1
  cout << endl;

  // 算法 algorithms
  v5[0] = 3; // v5 = (3 9 0 9 0)
  // 条件替换   <4 的都被替换成 7 
  replace_if(v5.begin(),v5.end(),f1,7); // v5 = (7 9 7 9 7)
  //  replace_if(v5.begin(),v5.end(), bind2nd(less(),4) ,7);
  //  bind2nd(op, a)是一个通用函数


  //直接替换 
  v5[0] = 3; v5[2] = v5[4] = 0; // v5 = (3 9 0 9 0)
  // 指定元素替换 0 -> 7 
  replace(v5.begin(),v5.end(),0,7); // v5 = (3 9 7 9 7)
  // sort 排序  快排 堆排 
  sort(v5.begin(),v5.end()); // v5 = (3 7 7 9 9)  升序排序 
  sort(v5.begin(),v5.end(),greater ()); // v5 = (9 9 7 7 3)  降序排序呢
  // 前方插入 
  // 例如对于整型向量，成员函数 front()的原 型为：int& front() ; 可以 放在 左边 也可以放在右边  
  v5.front() = 2; // v5 = (2 9 7 7 3)
  return 0;
  }
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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

使用自定义的类  作为 容器的元素  来使用 容器的一些算法

定义自己的类

 class Person {
 public:
    // 默认构造函数 
    Person(char *n = "", int a = 0) {
      name = strdup(n);// 复制字符串
      age = a;//复制年龄
    }
    // 默认析构函数
    ~Person(){
     free(name);//释放 字符串指向的空间
   }
   // 重载 等号判断 运算符  返回布尔量  输入为常量 的引用 避免拷贝 同时 常量 避免修改
   bool operator==(const Person& p) const {
     return strcmp(name,p.name) == 0 && age == p.age;// 名字 和年龄都必须相等
   }
   // 重载 小于号  运算符  返回布尔量
   bool operator<(const Person& p) const {
     return strcmp(name,p.name) < 0;//这里 使用 名字字符串 来比较
   }
   // 重载 大于号  运算符  返回布尔量
   bool operator>(const Person& p) const {
     return !(*this == p) && !(*this < p);// 使用了 ==  和 小于号
    }

 private:// 私有变量
   char *name;
   int age;
   friend bool lesserAge(const Person&, const Person&);//有元函数  使用年龄来比较两个对象的大小
 };
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
27
28
29

使用向量 容器来 存储 自定义的 Person类

 vector vp(1, Person("Golg",26));//Person("Golg",26)使用 默认构造函数创建一类对象存放在向量容器内
 // 增加两个对象
  vp.push_back(Person("Any",20));
  vp.push_back(Person("Bil",30));

 // 使用向量容器的 排序算法  默认需要类对象 提供 小于运算符的重载(比较函数)
 sort(vp.begin(), vp.end());
 //  vp=(("Golg",26)("Any",20))("Bil",30)) --> (("Any",20))("Bil",30)("Golg",26))
 // 逆序排列
 sort(vp.begin(), vp.end(), greater());
 // vp= (("Any",20))("Bil",30)("Golg",26)) --> (("Golg",26)("Bil",30)("Any",20)))

 // 那么如何 使用 年龄来排序呢 1提供比较函数(要是有元函数)  2直接修改 小于运算符的重载 函数 方法
 // 1提供比较函数(要是有元函数)
 bool lesserAge(const Person& p1, const Person& p2){
   return  p1.age < p2.age;//小于时为真
 }
 // 传递比较函数
 sort(vp.begin(), vp.end(), lesserAge);
 // vp=  (("Golg",26)("Bil",30)("Any",20))) ---> (("Any",20)("Bil",30)("Golg",26)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20