在写BlackJackGame的时候，考虑到要用到容器，所以就对容器的相关知识强化了一下：

因为我想的是有card类，最后要实现发牌，洗牌等等一系列的操作的时候，使用指向card类的对象的指针，将card类放在一个容器中方便操作：即在oneHand类中包含成员：vector<card*> myCards;

同样，可以在oneGame 类中也对player定义为vector 类型的：vector<player> onePlayer;

vector在C++中的用法有很多优秀的博客中都有详细的介绍，我自己对于vector的掌握还是基于在java中的过渡，原先在java中使用vector时的具体例子如下：

主要是在学java集合框架的时候，在集合框架中常见的实现类里面，有List接口和Map接口，而在List接口中，实现类有ArrayList 和 Vector,当时老师主要讲了ArrayList的用法，儿对于Vector知识做了简单的概述，所以我现在使用vector可能有很多不正确的用法（希望指正~~~）；但是闫老师教我们要善于使用API来查看各个类的构造方法和其中的使用方法：

其中，我打开API之后查到的vector的介绍如下：

public class Vector<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。

每个向量会试图通过维护 capacity 和 capacityIncrement 来优化存储管理。capacity 始终至少应与向量的大小相等；这个值通常比后者大些，因为随着将组件添加到向量中，其存储将按 capacityIncrement 的大小增加存储块。应用程序可以在插入大量组件前增加向量的容量；这样就减少了增加的重分配的量。

由 Vector 的 iterator 和 listIterator 方法所返回的迭代器是快速失败的：如果在迭代器创建后的任意时间从结构上修改了向量（通过迭代器自身的 remove 或 add 方法之外的任何其他方式），则迭代器将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就完全失败，而不是冒着在将来不确定的时间任意发生不确定行为的风险。Vector 的 elements 方法返回的 Enumeration 不是 快速失败的。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测 bug。

从 Java 2 平台 v1.2 开始，此类改进为可以实现 List 接口，使它成为 Java Collections Framework 的成员。与新 collection 实现不同，Vector 是同步的。

从以下版本开始：

JDK1.0

另请参见：

Collection, List, ArrayList, LinkedList, 序列化表格

构造方法摘要
Vector()           构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
Vector(Collection<? extends E> c)           构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。
Vector(int initialCapacity)           使用指定的初始容量和等于零的容量增量构造一个空向量。
Vector(int initialCapacity, int capacityIncrement)           使用指定的初始容量和容量增量构造一个空的向量。

方法摘要
boolean	add(E e)           将指定元素添加到此向量的末尾。
void	add(int index, E element)           在此向量的指定位置插入指定的元素。
boolean	addAll(Collection<? extends E> c)           将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素。
boolean	addAll(int index, Collection<? extends E> c)           在指定位置将指定 Collection 中的所有元素插入到此向量中。
void	addElement(E obj)           将指定的组件添加到此向量的末尾，将其大小增加 1。
int	capacity()           返回此向量的当前容量。
void	clear()           从此向量中移除所有元素。
Object	clone()           返回向量的一个副本。
boolean	contains(Object o)           如果此向量包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)           如果此向量包含指定 Collection 中的所有元素，则返回 true。
void	copyInto(Object[] anArray)           将此向量的组件复制到指定的数组中。
E	elementAt(int index)           返回指定索引处的组件。
Enumeration<E>	elements()           返回此向量的组件的枚举。
void	ensureCapacity(int minCapacity)           增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。
boolean	equals(Object o)           比较指定对象与此向量的相等性。
E	firstElement()           返回此向量的第一个组件（位于索引 0) 处的项）。
E	get(int index)           返回向量中指定位置的元素。
int	hashCode()           返回此向量的哈希码值。
int	indexOf(Object o)           返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回 -1。
int	indexOf(Object o, int index)           返回此向量中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1。
void	insertElementAt(E obj, int index)           将指定对象作为此向量中的组件插入到指定的 index 处。
boolean	isEmpty()           测试此向量是否不包含组件。
E	lastElement()           返回此向量的最后一个组件。
int	lastIndexOf(Object o)           返回此向量中最后一次出现的指定元素的索引；如果此向量不包含该元素，则返回 -1。
int	lastIndexOf(Object o, int index)           返回此向量中最后一次出现的指定元素的索引，从 index 处逆向搜索，如果未找到该元素，则返回 -1。
E	remove(int index)           移除此向量中指定位置的元素。
boolean	remove(Object o)           移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变。
boolean	removeAll(Collection<?> c)           从此向量中移除包含在指定 Collection 中的所有元素。
void	removeAllElements()           从此向量中移除全部组件，并将其大小设置为零。
boolean	removeElement(Object obj)           从此向量中移除变量的第一个（索引最小的）匹配项。
void	removeElementAt(int index)           删除指定索引处的组件。
protected  void	removeRange(int fromIndex, int toIndex)           从此 List 中移除其索引位于 fromIndex（包括）与 toIndex（不包括）之间的所有元素。
boolean	retainAll(Collection<?> c)           在此向量中仅保留包含在指定 Collection 中的元素。
E	set(int index, E element)           用指定的元素替换此向量中指定位置处的元素。
void	setElementAt(E obj, int index)           将此向量指定 index 处的组件设置为指定的对象。
void	setSize(int newSize)           设置此向量的大小。
int	size()           返回此向量中的组件数。
List<E>	subList(int fromIndex, int toIndex)           返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。
Object[]	toArray()           返回一个数组，包含此向量中以恰当顺序存放的所有元素。
<T> T[]	toArray(T[] a)           返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型。
String	toString()           返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式。
void	trimToSize()           对此向量的容量进行微调，使其等于向量的当前大小。

从类 java.util.AbstractList 继承的方法
iterator, listIterator, listIterator

从类 java.lang.Object 继承的方法
finalize, getClass, notify, notifyAll, wait, wait, wait

从接口 java.util.List 继承的方法
iterator, listIterator, listIterator

而在C++中，我们习惯于用数组来处理一系列的数值，在处理一些比较复杂的值时，就像这个游戏中要很好的利用C++的封装性的话，就要建立在类的基础上，虽然BlackJack游戏可以很简单的利用函数来实现，可以不用类来写，我的一位队友直接在主函数中一长串的跑了下来，虽然程序可以运行，但是个人觉得应该可以好好地利用C++的三大特点：

inheritance,   polymorphism ,  encapsulation这三个特性的原则来利用类的继承与封装性写~~~~

所以，在C++中，标准模板库STL提供了一组容器、算法、迭代器等其他的许多功能；

迭代器是用来标识容器中的元素的对象，可以利用迭代器来处理各个元素。下面我先举一个使用vector的例子：

首先在头文件中要包含<vector>

#include<iostream>

#include<vector>

using namespace std;

int main()

{

    vector<string> myterm;  // 声明一个名为myterm的空白变量，包含string 对象元素，空白变量可以方便在添加新元素时扩大

    myterm.push_back("Kai She"); //push_back()成员函数向容器的最后添加一个新的元素

    myterm.push_back("Cai Baobao");

    myterm.push_back("This is me");

    cout << " You have :" << myterm.size() <<" terms\n";

    cout <<" Your terms are:\n";

    for (int i = ; i < myterm.size(); ++i)

        cout << "\t " << myterm[i]<< endl;

    cout << " Because you are not excellent enough , you were pop" << endl;

    myterm.pop_back();//删除最后一个元素并且将myterm的长度减少1.

    cout << " Your terms now are:\n";

    for (int i = ; i < myterm.size(); ++i)

        cout << myterm[i] << endl;

}

可以看一下其运行结果：

,