STL模版-vector详解

3. vector容器

	（1）普通数组与vector

	只要能够使用数组的地方，就一定可以使用vector代替，前面说到，vector其实就是
	数组，只是空间开辟于堆中。普通数组长度是固定的，但是vector容器的容量和大小
	可以根据实际情况不同而改变。

	容量与大小：
	对于vector来说容量和大小是不同的，容量>=大小，
	容量：vector容器最大能够存放的元素个数。
	大小：vector容器当前实际存放的元素个数。
	
	使用数组存放数据时实际上也存在容量与大小的关系，只是平时我们不并
	不关心这个问题。

	当数组空间未存满时，数组实际元素个数就是大小，数组的最大元素空间
	就是容量。

	获取vector的容量和大小：
	分别通过vector的size()和capacity()成员函数便可以获取vector的容
	量和大小。

	（2）vector容器的优缺点
	优点：vector容器的容量和大小可以可根据情况变更。
	缺点：vector本质上是一个单端数组，在其末尾添加和删除元素，效率都很高，
		但是在vector的中间插入和删除效率就很低，这会导致大量的元素需
	要被移动。
	
	（3）创建vector
	（1）创建一个空的，存放基本类型数据的vector
	std::vector<int> v;
	
	vector属于std命名空间，因此需要使用std::，该定义表示利用vector
	容器类的默认构造器创建了一个vector，该容器存放的数据类型为int型，
	vector的容量和大小都是0。
	
	cout <<"大小："<< v.capacity() <<endl;
	cout <<"容量："<< v.size() <<endl;
	打印结果都为0。
	
	创建一个空的vector容器并不是一种高效的创建方式，因为向vector
	容器添加新元素时，会导致频繁的扩充容器空间，操作效率很低，因此
	很多时候我们都会给容器预先指定一定大小的初始空间，提高操作效率。
	

	（2）创建一个有一定大小vector

   （1）创建存放基本类型数据的vector
	std::vector<int> v(10);
	
	调用vector容器的有参构造函数，该参数用于说明容器的大小和容量。

	创建有一定空间，用于存放基本类型数据的vector时，
	（1）所有元素都会被初始化为0
	（2）最开始时，容器的容量==大小，

	比如打印出定义的v的容量和大小，
	cout <<"容量："<< v.capacity() <<endl;
	cout <<"大小：" v.size() <<endl;
	打印结果都为10。
	
	当向容器里面插入新的数据时，容器中的容量扩大的速度大于大小扩大的速度，
	多出来的冗余空间是为了提高容器的效率。
	比如：
	  v.insert(v.begin(), 23);
    
    	cout <<"容量：" v.capacity() << endl;
	cout <<"大小：" v.size() << endl;

	打印结果：
	  容量：20
	  大小：11


   （2）创建存放类类型对象的vector	

	student() {
	public:
	private:
		string anme;
		int num;
	};
	std::vector<Student> vstus(20);
	
	创建一个vector容器，包含20个Student对象，每个对象都调用Student
	类的默认构造函数进行初始化，所以对于Student类来说，要求必须实现
	其默认构造函数。
	
	由于这里定义的Student类没有其它构造函数，所以编译器会提供默认
	构造函数。

	至于需不需要显式定义拷贝构造函数和析构函数，需要根据实际情况而
	定，为了保证类定义标准化和完整性，建议写出。
	
	在类中最好提供=和<的重写，否则当涉及给最容器中的内容进行排序时，
	可能会出现问题。不过很多时候，容器都提供了默认的比较方法，因此
	都能按照默认比较方法对容器中的数据进行排序。
	
	
（3）创建时给容器给一些初始值
	不能够直接使用一组数据初始化vetor容器，但是可以使用定义好的c++
	数组初始化vector容器。

	（1）方法1：赋值
		（1）基本类型数据
			int buf[] = {1, 2, 4, 3, 6, 7, 8, 9, 0}; 
    			std::vector<int> v(10);

    			for(int i=0; i<sizeof(buf)/sizeof(buf[0]); i++) {
            			v[i] = buf[i];
    			}   

    			for(int i=0; i<v.size(); i++) {
            			cout << v[i] << endl;
    			}   

   	 	（2）类对象
			#include <iostream>
			#include <stdio.h>
			#include <vector>

			using namespace std;
			/* 定义一个学生结构体 */
			class Student {
			public:
    				Student(const string name=" "):name(name) { }
    				string name;
			};

			int main(void)
			{    
    				/* 定义一个对象数组并初始化对象数组 */
    				Student stu[10];
    				char tmp[3] = {0};
    				string n("name");
    				for(int i=0; i<sizeof(stu)/sizeof(stu[0]); i++) {
            				sprintf(tmp, "%d", i);
            				stu[i] = Student(n+tmp);
    				}

    				/* 使用赋值的方式，对象数组元素赋值给vector容器 */
    				std::vector<Student> v(10);
    				for(int i=0; i<sizeof(stu)/sizeof(stu[0]); i++) {
            				v[i] = stu[i];
    				}

    				for(int i=0; i<v.size(); i++) {
            				cout << v[i].name << endl;
    				}

    				return 0;
			}	
			
	（2）方法2
		（1）基本类型
			int buf[] = {1, 2, 4, 3, 6, 7, 8, 9, 0}; 
    			std::vector<int> v(buf, buf+sizeof(buf)/sizeof(buf[0]));

    			for(int i=0; i<v.size(); i++) {
            			cout << v[i] << endl;
    			}  
			或者
			std::vector<int> v(10， 3.14);

    			for(int i=0; i<v.size(); i++) {
            			cout << v[i] << endl;
    			}
			创建一个10个元素空间的vector容器，初始值都是3.14。
		（2）类对象
			#include <iostream>
			#include <stdio.h>
			#include <vector>

			using namespace std;

			/* 定义一个学生结构体 */
			class Student {
			public:
    				Student(const string name=" "):name(name) { }
    				string name;
			}; 
			
			int main(void)
			{    
    				/* 定义一个对象数组并初始化对象数组 */
    				Student stu[10];
    				char tmp[3] = {0};
    				string n("name");
    				for(int i=0; i<sizeof(stu)/sizeof(stu[0]); i++) {
            				sprintf(tmp, "%d", i); 
           				 	stu[i] = Student(n+tmp);
    			}

    			/* 利用对象数组初始化vector容器 */
    			std::vector<Student> v(stu, stu+sizeof(stu)/sizeof(stu[0]));

    			for(int i=0; i<v.size(); i++) {
            			cout << v[i].name << endl;
    			}

    			return 0;
		}
		
		从例子中不难看出，构造函数需要两个迭代器参数用于指定间隔，
		这里使用的是指针，前面讲过，指针其实就是一种特殊的迭代器，

		这两个参数指定的是半开间隔，所谓半开间隔（半开区间）就是
		包含前一个范围界限，但是不包含后一个范围界限。	
			
（4）resize()函数和reserve()函数
	（1）resize()函数
		利用参数指定新的元素个数，用于修改容器的大小（不是容量），
		如果新的大小比原来小，尾部元素就被删除。如果比原来大小
		要大，就在容器尾部添加新元素空间，如果数据是基本类型，
		新加的元素的默认值为0，如果对象的话，需要看实际情况。
		        std::vector<int> v(10);

    			cout << v.size() << endl;
    			v.resize(6);
    			cout << v.size() << endl;

		
	（2）reserves()函数
		利用其参数用于指定vector容器的最小容量，如果设置的容量
		值小于当前容量，容量就保持不变。		
		        std::vector<int> v(10);

    			cout << v.capacity() << endl;
    			v.reserve(16);
    			cout << v.capacity() << endl;

		
（5）在容器中存放指针

	在前面的内容提到过，可以在容器中存放副本和指针，存放副本方式的
	效率比较低，修改了副本后，原对象的值不会变化，修改了原对象的值
	后，容器中存放的副本的值又不会发生变化。
		
	存放指针可以提高效率，但是要注意，如果容器存放的指针指向的空间
	释放了的话会造成野指针，因此使用时需要格外小心。
	
	（1）例子：存放副本的
		#include <iostream>
		#include <stdio.h>
		#include <vector>

		using namespace std;
		/* 定义一个学生结构体 */
		class Student {
		public:
    			Student(const string name=" "):name(name) { }
    			string name;
		};


		int main(void)
		{    
    			Student stu[5];
    			std::vector<Student> v(5);

    			for(int i=0; i<5; i++) {
            			stu[i] = Student("name");
            			v[i] = stu[i];
    			}

    			for(int i=0; i<5; i++) cout << v[i].name <<endl;

    			cout<<endl;
    			stu[4].name = "zhangsan";
    			for(int i=0; i<5; i++) cout << v[i].name <<endl;
            
    			return 0;
		}       
	
		运行结果：
		name
		name
		name
		name
		name

		name
		name
		name
		name
		name

		例子分析：
		由于vector容器中存放的是副本，因此对原内容修改后，容器
		中的内容并不会发生改变。

	（2）例子：存放指针
		还是继续上面的例子，只是将容器中存放的数据改为指针。
		将主函数的内容修改为如下：

        	Student *stu[5];
    		std::vector<Student *> v(5);

        	for(int i=0; i<5; i++) {
    	        	stu[i] = new Student("name");
            		v[i] = stu[i];
        	}

        	for(int i=0; i<5; i++) cout << v[i]->name <<endl;

        	cout<<endl;
    		stu[4]->name = "zhangsan";
    		for(int i=0; i<5; i++) cout << v[i]->name <<endl;


		运行结果：
		name
		name
		name
		name
		name

		name
		name
		name
		name
		zhangsan

		例子分析：
		由于容器中存放的时指针，因此利用指针修改的是原对象的内容。	

（4）访问（读写）vector容器中元素	
（1）使用[]访问
	在之前访问vector容器的例子中，我们一直使用的都是[]的方式进行
	容器元素的当问。
	
（2）迭代器访问
   （1）正向迭代器
	涉及的成员函数。
	begin()：返回迭代器，它指向第一个元素
	end()：返回迭代器，它指向最后一个元素后面的元素
	
	对迭代器可以++/--，+b/-n运算，使用*解引用后，就可以可以访问迭代器指向的元素内容。
	
	例子：
	#include <iostream>
	#include <stdio.h>
	#include <vector>

	using namespace std;
	class Student { 
	public:            
    		Student(const string name=" "):name(name) { } 
    		string name;
	};                  

	void show_vector(std::vector<Student *>::iterator first, std::vector<Student *>::iterator last) {
    		for(; first!=last; first++) 
            		cout << (*first)->name <<endl;
	}


	int main(void)
	{
    		Student *stu[5];
    		std::vector<Student *> v(5);

    		for(int i=0; i<5; i++) {
            		stu[i] = new Student("name");
            		v[i] = stu[i];
    		}

    		show_vector(v.begin(), v.end());

    		(*(v.begin()+2))->name = "wangwu";
    		(*(v.end()-1))->name = "lisi";

    		cout<<endl;
    		show_vector(v.begin(), v.end());

    		return 0;
	}
	运行结果：
	name
	name
	name
	name
	name

	name
	name
	wangwu
	name
	lisi
	
	例子分析：
	
	（迭代器其实是一种抽象的指针，可以这么理解，所有需要解引用才可以访问）
	
	begin和end函数返回的是vcteor容器提供的随机迭代器，访问器所指
	向的元素时，需要使用*进行解引用，由于容器中存放的是对象的地址，
	因此访问对象的name时，需要使用->访问符。

    （2）反向迭代器
	vector提供的反向迭代器为std::vector<Student *>::reverse_iterator
	与之对应的是rbegin()和rend()函数。使用反向迭代器时，不能使用
	用begin()和end()函数，反之也是如此。

	请自己写代码验证反向迭代器。
	
（3）直接访问元素内容		
	涉及的成员函数：
	（1）front()：引用第一个元素
	（2）back()：引用最后一个元素
	（3）at()：引用指定索引的元素

	可以直接访问空间，不需要*解引用。

	#include <iostream>
	#include <stdio.h>
	#include <vector>

	using namespace std;
	class Student {
	public:
    		Student(const string name=" "):name(name) { }
    		string name;
	};

	void show_vector(std::vector<Student *> &v) {
    		for(int i=0; i<v.size(); i++)
            		cout << v.at(i)->name <<endl;
	}

	int main(void)
	{
    		Student *stu[5];
    		std::vector<Student *> v(5);

    		for(int i=0; i<5; i++) {
            		stu[i] = new Student("name");
           			v[i] = stu[i];
    		}

   	 		show_vector(v);

    		v.front()->name = "wangwu";
    		v.back()->name = "joinash";
   			v.at(2)->name = "washion";

    		cout<<endl;
    		show_vector(v);

    		return 0;
	}
	运行结果：
	name
	name
	name
	name
	name

	wangwu
	name
	washion
	name
	joinash
	
（3）vector访问方式总结
	从前面的了解中，我们不难发现，vector的访问方式非常灵活，使用
	[]/迭代器/直接访问等方式都可以。
	

	
（5）使用vector提供的成员函数来添加/删除vector中的元素
（1）涉及的成员函数
	（1）push_back()：把参数（对象）添加到vector的最后位置
	（2）pop_back()：删除vector尾部的元素
	（3）erase()：删除任意位置的一个或者多个元素
	（4）clear()：删除所有的元素
	（5）insert()：在vector中的指定位置插入一个或多个对象。
		该函数提供了两个重载版本和一个函数模板。
		iterator insert ( iterator position, const T& x );
		void insert ( iterator position, size_type n, const T& x );
		template <class InputIterator> void insert ( iterator position, InputIterator first, InputIterator last );
	（6）empty()：判断vector是否为空，避免对空vector进行操作。
		
		
（2）例子
	#include <iostream>
	#include <stdio.h>
	#include <vector>
	#include <algorithm>

	void show_vector(std::vector<int>::iterator first, std::vector<int>::iterator end) {
    		for( ;first!=end; first++) cout << *first << " ";
    		cout << endl;
		cout << endl;
	}

	int main(void)
	{
    		int buf[] = {1, 2, 3, 5, 4, 7, 8, 9, 0, 23, 54, 32};
    		std::vector<int> v;

    		cout << "将buf中下表[1-10)元素插入v，1-10是半开区间，含1不含10 "<<endl;
    		v.insert(v.end(), buf+1, buf+10);
    		show_vector(v.begin(), v.end());

    		cout << "添加一个元素7到vector的末尾"<<endl;
    		v.push_back(7);
    		show_vector(v.begin(), v.end());

    		cout << "删除最后一个元素" << endl;
    		v.pop_back();
    		show_vector(v.begin(), v.end());

    		cout << "删除第2个到第5个半开区间的元素" << endl;
    		v.erase(v.begin()+1, v.begin()+4);
    		show_vector(v.begin(), v.end());

		    cout << "在第4个元素未知插入元素111"<<endl;
   		 	v.insert(v.begin()+3, 111);
    		show_vector(v.begin(), v.end());

    		return 0;
	}
	运行结果：
	将buf中下表[1-10)元素插入v，1-10是半开区间，含1不含10 
	2 3 5 4 7 8 9 0 23 

	添加一个元素7到vector的末尾
	2 3 5 4 7 8 9 0 23 7 

	删除最后一个元素
	2 3 5 4 7 8 9 0 23 

	删除第2个到第5个半开区间的元素
	2 7 8 9 0 23 

	在第4个元素未知插入元素111
	2 7 8 111 9 0 23 

	
（6）迭代器的好处
（1）数组传参操作
	（1）传统方式
		例子：求平均值
		#include <iostream>
		float average(float *buf, int count) {
    			int sum = 0;
    			for(int i=0; i<count; i++) {
            			sum += buf[i];
    			}
    			return sum/count;
		}

		int main(void)
		{
			float ret = 0;
    			float buf[] = {1, 2, 3, 5, 4, 7, 8, 9, 0, 23, 54, 32};
    
    			average(buf, sizeof(buf)/sizeof(buf[0]));
            
    			return 0;
		} 

		例子分析：
		上面显示了数组的经典传参方式，对于数组来说，必须传递两个参数，
		第一个是地址，第二是元素个数。

		但是对于字符串传参来说就不需要传递元素个数，字符串实际上是一
		个特殊形式的字符数组，由于字符串使用\0作为结尾标志，省去了需
		要传递元素个数的可能。


	    函数模板实现求平均值：
		有的时候可能会对很多类型都要做求平均的运算，因此可以将求平均
		运算定义为一个模板，这样的话就可以根据情况的不同，生成各种不
		同求平均值的函数实例。
		#include <iostream>
		template <class T1> float average(T1 *buf, int count) {
    			T1 sum = 0;
    			for(int i=0; i<count; i++) {
            			sum += buf[i];
    			}   
    			return sum/count;
		}       
    
		int main(void)
		{
    			float ret = 0;
    			float buf[] = {1, 2, 3, 5, 4, 7, 8, 9, 0, 23, 54, 32};
        
    			ret = average(buf, sizeof(buf)/sizeof(buf[0]));
    			cout <<"平均值="<< ret << endl; 
        
    			return 0;
		}    
	
	（2）传递首尾指针方式（迭代器）
		#include <iostream>
		float average(float *first, float *last) {
    			int sum = 0;
   		 		int count = last - first;
    			for( ; first!=last; first++) {
            			sum += *first;
    			}   
    			return sum/count;
		}
		int main(void)
		{
    			float ret = 0;
    			float buf[] = {1, 2, 3, 5, 4, 7, 8, 9, 0, 23, 54, 32};

    			ret = average(buf, buf+sizeof(buf)/sizeof(buf[0]));
    			cout <<"平均值="<< ret << endl;

    			return 0;
		}

	     函数模板实现求平均值：	
		前面提到过，指针本身就是一种特殊的迭代器，对于数组的传参，
		可以使用传递首尾指针（半开区间）的方式。

		#include <iostream>
		template <class iter> float average(iter first, iter last) {
    			int sum = 0;
    			int count = last - first;
    			for( ; first!=last; first++) {
           			 	sum += *first;
    			}
    			return sum/count;
		}
	
		int main(void)
		{
    			float ret = 0;
    			float buf[] = {1, 2, 3, 5, 4, 7, 8, 9, 0, 23, 54, 32};

    			ret = average(buf, buf+sizeof(buf)/sizeof(buf[0]));
    			cout <<"平均值="<< ret << endl;

    			return 0;
		}

		例子分析：
		由于没有传递元素个数，所以需要使用首尾指针相减得到元素
		个数。


（2）vector传参操作
	（1）普通方式
		#include <iostream>
		#include <vector>

		float average(std::vector<int> &v) {
    			int sum = 0;
    			int count = v.size();
    			for(int i; i<v.size(); i++) {
            			sum += v[i];
    			}
    			return sum/count;
		}

		int main(void)
		{
    			float ret = 0;
    			float buf[] = {1, 2, 3, 5, 4, 7, 8, 9, 0, 23, 54, 32};
    			std::vector<int> v(buf, buf+sizeof(buf)/sizeof(buf[0]));

    			ret = average(v);
    			cout <<"平均值="<< ret << endl;

    			return 0;
		}
		例子分析：
		将vector对象直接以引用方式进行传参操作。

	   函数模板求平均值：
		#include <iostream>
		#include <vector>
		template<class T> float average(T &v) {
    			int sum = 0;
    			int count = v.size();
    			for(int i; i<v.size(); i++) {
            			sum += v[i];
    			}
    			return sum/count;
		}

		int main(void)
		{
    			float ret = 0;
    			float buf[] = {1, 2, 3, 5, 4, 7, 8, 9, 0, 23, 54, 32};
    			std::vector<int> v(buf, buf+sizeof(buf)/sizeof(buf[0]));

    			ret = average(v);
    			cout <<"平均值="<< ret << endl;

    			return 0;
		}

	（2）迭代器	
		#include <iostream>
		#include <vector>	
		float average(std::vector<int>::iterator first, std::vector<int>::iterator last) {
    			int sum = 0;
    			int count = last - first;
    			for( ; first!=last; first++) {
            			sum += *first;
    			}
    			return sum/count;
		}

		int main(void)
		{
    			float ret = 0;
    			float buf[] = {1, 2, 3, 5, 4, 7, 8, 9, 0, 23, 54, 32};
    			std::vector<int> v(buf, buf+sizeof(buf)/sizeof(buf[0]));

    			ret = average(v.begin(), v.end());
    			cout <<"平均值="<< ret << endl;

    			return 0;
		}

		例子分析：
		从这个例子你会发现，这个vector迭代器的传参与传递数组
		首尾指针的方式时一样的，从这一点你也可以看出，指针其
		实就是迭代器的原始实现方式。

	   函数模板求平均值：
		template<class iter> float average(iter first, iter last) {
    			int sum = 0;
    			int count = last - first;
    			for( ; first!=last; first++) {
            			sum += *first;
    			}   
    			return sum/count;
		}

		int main(void)
		{
    			float ret = 0;
    			float buf[] = {1, 2, 3, 5, 4, 7, 8, 9, 0, 23, 54, 32};
    			std::vector<int> v(buf, buf+sizeof(buf)/sizeof(buf[0]));

    			ret = average(v.begin(), v.end());
    			cout <<"平均值="<< ret << endl;

    			return 0;
		}
		
		例子分析：
		这个与传递数组首尾指针的方式是完全一样的，只是这里使
		用的不是普通的指针，使用的是由容器自己提供的迭代器。

	
（3）求用输入输出流迭代器获取到的数据的平均值

   （1）输入流迭代器
	
	前面的例子中都是将数据先存入数组或者vector容器。

	当希望对输入数据求平均值时，传统的做法是先将输入数据存放到数组或
	者vector后，再调用average函数求平均值。

	但是如果使用输入输出流迭代器的话，可以省去将数据暂存到数组或者
	vector环节。

	例子：
	#include <iostream>
	#include <stdio.h>
	#include<iterator>

	template<class iter> float average(iter first, iter last) {
    		int sum = 0;
    		int count = 0;
    		for( ; first!=last; first++, count++) {
            		sum += *first;
    		}   
    		return sum/count;
	}
      
	int main(void)
	{
    		float ret = 0;

    		cout << "请输入一组需要求平均值的数，之用空格分隔" << endl;     
    		ret = average(istream_iterator<float>(cin), istream_iterator<float>());
    		cout <<"平均值="<< ret << endl; 
        
    		return 0;
	}   
		
	例子分析：
	例子中，直接使用输入迭代器从输入流cin中获取数据，但是count中不
	能直接通过迭代器相减的方式得到，因为输入的个数不能立即确定，所
	以只能使用count++的方式计算count。
	

	改变输入迭代器的输入流：
	对于输入迭代器来说，给定不同的输入流可以对不同来源的数据进行操作，
	比如下面的这个例子：

	#include <iostream>
	#include<iterator>
	#include<sstream>

	template<class iter> float average(iter first, iter last) {
    		int sum = 0, count = 0;
    		for( ; first!=last; first++, count++) {
            		sum += *first;
    		}
    		return sum/count;
	}

	int main(void)
	{
    		float ret = 0;
    		string str = "1 34 45 67 78 44 33";
    		istringstream iss(str);

    		ret =average(std::istream_iterator<float>(iss), std::istream_iterator<float>());
    		cout <<"平均值="<< ret << endl;

    		return 0;
	}

	例子分析：
	输入迭代器中，将字符串输入流作为了输入迭代器的参数，因此，输
	入的数据来自于字符串。
			

	（2）输出流迭代器
	如果希望在averae函数中将所有的数据显示出来，除了可以使用循环
	打印外，还可以使用输出流迭代器实现。

	例子：
	#include <iostream>
	#include <algorithm>
	#include<iterator>

	void show_vector(int *first, int *last) {
    		std::copy(first, last, ostream_iterator<int>(cout, " "));
    		cout << endl;
	}

	int main(void)
	{
    		int buf[] = {4, 2, 5, 1, 3, 7, 8, 45, 32, 12};

    		show_vector(buf, buf+sizeof(buf)/sizeof(buf[0]));

    		return 0;
	}
	例子分析：
	直接将指针当作迭代器使用，
	std::copy(first, last, ostream_iterator<int>(cout, " "));
		
	调用了算法copy函数，该函数的表示，将迭代器first和last之间的
	数据复制给输出迭代器，最后输出迭代器利用cout将数据输出显示，
	数据之间使用" "间隔。

	如果输出流并不是cout，而是一个普通文件流，那么数据将会被输入
	到文件中。
	
	

（4）定义一个对数组/vector/输入迭代器都适用的average函数模板

	通过起那面的例子，不难发现，通过迭代器的使用，完全可以定义一个
	针对数组/vector/输入迭代器都适用的average函数模板，由此可以看
	出迭代器的好处。

	#include <iostream>
	#include <algorithm>
	#include <vector>
	#include<iterator>

	template<class iter> float average(iter first, iter last) {
    		int sum = 0, count = 0;
    		for( ; first!=last; first++, count++) {
            		sum += *first;
    		}   
    		return sum/count;
	}	

	int main(void)
	{
    		float ret = 0;
    		float buf[] = {4, 2, 5, 1, 3, 7, 8, 45, 32, 12};
    		std::vector<float> v(buf, buf+sizeof(buf)/sizeof(buf[0]));

    		cout<<"1.计算数组中数据的平均值" <<endl;
    		cout<<"2.计算vector容器中数据的平均值" <<endl;
    		cout<<"3.计算从键盘输入数据的平均值" <<endl;
    		int select = 0;
    		cin >> select;

        	if(1 == select) {
            		ret = average(buf,  buf+sizeof(buf)/sizeof(buf[0]));
    		} else if(2 == select) {
            		ret = average(v.begin(),  v.end());
    		} else if(3 == select) {
            		cout << "请输入一组需要求平均值的数，使用空格分隔" << endl;
            		ret =average(std::istream_iterator<float>(cin), std::istream_iterator<float>());
    		}

    		cout <<"平均值="<< ret << endl;

    		return 0;
	}

	例子分析：
	有三种不同的选择，分别对数组/vector容器/输入的数据进行求平均
	值，但是这三种情况下使用的是同一个模板，这个模板会根据不同的
	情况生成不同的函数实例。