java 里的，vector是什么? 起到什么用，何时才会用到？？

c++中，vector作为容器，它的作用是：用来存放结构体struct类型的变量。以下是vector的具体用法：工具/材料：电脑、c++编译器1、首先，打开c++编译器，构造一个int类型的空vector向量。2、程序运行结果如图，可以看到vector的size为0。3、如红框勾选所示，构造了6个元素值为20的vector向量。4、运行结果显示，成功的构造了6个元素为20的向量。5、以现有vector对象的范围作为构造函数的参数，同样也将对象复制给另一个vector对象。6、以下，就是程序运行结果了。

resize是改变容器的大小，并且创建对象

Vector 容器：vector类称作向量类，它实现了动态的数组，用于元素数量变化的对象数组。构造函数：vector（）：创建一个空的vector。vector（itn nSize）：创建一个vector，元素个数为nSize。vector（int nSize， const T& t）：创建一个vector，元素个数为nSize，且值均为t。vector（const vector&）：拷贝构造函数。vector<int>a,b(n,0)的意思就是 创建了一个 int 类型的空的vector容器a，和一个 int 类型n个元素，且值均为0的vecotr容器b。

C++中是向量的意思，一种类型~~~

STL STL = Standard Template Library，标准模板库，惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来的。这可能是一个历史上最令人兴奋的工具的最无聊的术语。从根本上说，STL是一些“容器”的集合，这些“容器”有list,vector,set,map等，STL也是算法和其他一些组件的集合。这里的“容器”和算法的集合指的是世界上很多聪明人很多年的杰作。STL的目的是标准化组件，这样就不用重新开发，可以使用现成的组件。STL现在是C++的一部分，因此不用额外安装什么。它被内建在你的编译器之内。 在C++标准中，STL被组织为下面的13个头文件：<algorithm>、<deque>、<functional>、<iterator>、<vector>、<list>、<map>、<memory>、<numeric>、<queue>、<set>、<stack>和<utility>。

百度解释非常详细

向量在Unity的含义在Unity中最常用的类就是Vector3这个类了，简单的说是向量，实际上远非如此。在Unity中Vector3有一下几种含义1. 三个数字打一包：这种用法没有几何意义，就是三个数，没其他的。比如欧拉角，缩放比例，都是这样的用法，这种情况不能看成是向量。所以对这种用法做向量运算的话结果可能会很奇怪。2. 空间位置的“点”：关键词是“点”，这种情况用的最多的是transform.Position，它表示的是位置，与x，y，z坐标对应，在某些计算下有集合含义，可以做运算。3. 空间位置的“方向线段”：方向线段这才是向量真正的姿态，一个向量有两个含义：大小和方向，所以向量可以拆分成两部分来看，大小就是模（|v|），方向就是标准化(Vn)，例如描述一个朝Vn方向大小为|v|的速度。这里有一个隐藏属性，就是从原点（0,0,0）出发。两点一线。所以向量可以分解为v=|v|* Vn向量和常数(i)的运算：不能加减。iV=Vi=(ix,iy,iz) 满足交换律。代表把线拉长多少倍V/i = (x/i, y/i, z/i) 注意 i/V是不行的。代表把线缩小多少倍向量的常用运算和意义：1. 向量的长度（模|v|）注意只有当做”方向线段“的时候模才有意义，简单的说就是这条线有多长，就是你用尺子量出来的数据。公式： 脚本：v.magnitude，v.sqrMagnitudesqrMagnitude代表模的平方，为啥会有这么个东西呢？其实仅仅是因为平方根的计算会很耗时，sqrMagnitude的效率会高很多，例如在比较模的大小这类的问题上，比较sqrMagnitude的大小就足够了。2. 向量的标准化（单位向量 Vn）同样，是对“方向线段”的描述, 意思是把这条线拉长或者缩短，让他的模等于1，他最大的作用就是表示方向，判断两个向量是不是一个方向，判断Vn就可以了。公式：脚本：v.normalized， v.Normalize()使用技巧：如要把任意V长度变成5，直接5*Vn就可以了v.normalized是计算自己标准后的向量，然后返回别处用，自己的值不会改变。v.Normalize()是把自己标准化，自己的值会改变。3. 向量相加（Va+Vb）看做“方向线段”可以用来表示路径，速度等的叠加。例如：走到a点再走到b点的结果。先以速度a出发再受到速度b的结果。公式：脚本: 直接写Va+Vb4. 向量相减（Va-Vb）看做“点”时表示:将两点连成方向线段，方向由b指向a。如此一来要计算两点之间的距离和相对方向就很容易了，距离是|Va-Vb|, 相对方向是Va-Vb再标准化。这个很实用看做“方向线段”可以用来求速度，路径等的逆运算，回滚等。公式：脚本: 直接写Va-Vb5. 向量点乘（Va.Vb）具体含义比较模糊代表，在物理学中，已知力与位移，点乘的结果为功, 看做“方向线段”可以用来求夹角，个人感觉这是最有用的地方。公式： 注意结果是一个常数脚本: Vector3.Dot(va, vb)实用技巧：，可以直接得到夹角，比较好的是Unity提供了这个方法Vector3.Angle(Va, Vb)。6. 向量叉乘（Va x Vb）这个感觉很少用，我也几乎没用过，坐等大神来解答脚本: Vector3. Cross (va, vb)7. 投影（Vp）V在轴Vb上的影子, 这个概念不好说清楚，可以去问度娘，可以用来做向量的切割，比如要限制物体的运动方向时可以使用投影。公式：脚本: Vector3.Project(V, Vb);8. 反射（Vr）V对于法线N的反射，这个最有意思了，想想一下光反射或者桌球反弹，就是那个概念。可以用于模拟一下物理碰撞。公式： 注意此处N需要标准化脚本: Vector3. Reflect (V, N);

可以用迭代器的方式vector<int> data;vector<double> data_d(data.begin(), data.end());

在c++中，vector是一个十分有用的容器，下面对这个容器做一下总结。1 基本操作(1)头文件#include<vector>.(2)创建vector对象，vector<int> vec;(3)尾部插入数字：vec.push_back(a);(4)使用下标访问元素，cout<<vec[0]<<endl;记住下标是从0开始的。(5)使用迭代器访问元素.vector<int>::iterator it;for(it=vec.begin();it!=vec.end();it++) cout<<*it<<endl;(6)插入元素： vec.insert(vec.begin()+i,a);在第i+1个元素前面插入a;(7)删除元素： vec.erase(vec.begin()+2);删除第3个元素vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始(8)向量大小:vec.size();(9)清空:vec.clear();2vector的元素不仅仅可以使int,double,string,还可以是结构体，但是要注意：结构体要定义为全局的，否则会出错。下面是一段简短的程序代码：#include<stdio.h>#include<algorithm>#include<vector>#include<iostream>using namespace std;typedef struct rect{ int id; int length; int width;　　//对于向量元素是结构体的，可在结构体内部定义比较函数，下面按照id,length,width升序排序。　　bool operator< (const rect &a) const { if(id!=a.id) return id<a.id; else { if(length!=a.length) return length<a.length; else return width<a.width; } }}Rect;int main(){ vector<Rect> vec; Rect rect; rect.id=1; rect.length=2; rect.width=3; vec.push_back(rect); vector<Rect>::iterator it=vec.begin(); cout<<(*it).id<<" "<<(*it).length<<" "<<(*it).width<<endl; return 0;} 3 算法(1) 使用reverse将元素翻转：需要头文件#include<algorithm>reverse(vec.begin(),vec.end());将元素翻转(在vector中，如果一个函数中需要两个迭代器，一般后一个都不包含.)(2)使用sort排序：需要头文件#include<algorithm>，sort(vec.begin(),vec.end());(默认是按升序排列,即从小到大).可以通过重写排序比较函数按照降序比较，如下：定义排序比较函数：bool Comp(const int &a,const int &b){ return a>b;}调用时:sort(vec.begin(),vec.end(),Comp)，这样就降序排序。

*VECTOR 就是生物载体，带原者，通常是一种昆虫或蜱，能把一种疾病或寄 生虫从一种动物或植物传给另一种动物或植物。*VECTOR 也是分子生物学的｀向量＇将遗传物质转移到目标细胞的载体， 例如：Plasmid vector 质粒载体，Binary vector 二进制向量，Cloning vector 克隆载体，Expression vector 表达载体，Shuttle vector 穿梭载体。 Viral vector 病毒载体。*Dispersal vector 传播载体（如种子、孢子或花粉）。 及授粉及传粉者载体 biotic vector 等。

http://blog.sina.com.cn/s/blog_60792c900100f3l8.html

Maybe "容器"

就是“向量”

cout<<tmp[i].x<<tmp[i].y<<endl; 这样就可以了

vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。为了可以使用vector，必须在你的头文件中包含下面的代码：#include<vector>vector属于std命名域的，因此需要通过命名限定，如下完成你的代码：usingstd::vector;vector<int>vInts;或者连在一起，使用全名：std::vector<int>vInts;建议使用全局的命名域方式：usingnamespacestd;函数表述c.assign(beg,end)c.assign(n,elem)将[beg;end)区间中的数据赋值给c。将n个elem的拷贝赋值给c。c.at(idx)传回索引idx所指的数据，如果idx越界，抛出out_of_range。c.back()传回最后一个数据，不检查这个数据是否存在。c.begin()传回迭代器中的第一个数据地址。c.capacity()返回容器中数据个数。c.clear()移除容器中所有数据。c.empty()判断容器是否为空。c.end()指向迭代器中末端元素的下一个，指向一个不存在元素。c.erase(pos)c.erase(beg,end)删除pos位置的数据，传回下一个数据的位置。删除[beg,end)区间的数据，传回下一个数据的位置。c.front()传回第一个数据。get_allocator使用构造函数返回一个拷贝。c.insert(pos,elem)c.insert(pos,n,elem)c.insert(pos,beg,end)在pos位置插入一个elem拷贝，传回新数据位置。在pos位置插入n个elem数据。无返回值。在pos位置插入在[beg,end)区间的数据。无返回值。c.max_size()返回容器中最大数据的数量。c.pop_back()删除最后一个数据。c.push_back(elem)在尾部加入一个数据。c.rbegin()传回一个逆向队列的第一个数据。c.rend()传回一个逆向队列的最后一个数据的下一个位置。c.resize(num)重新指定队列的长度。c.reserve()保留适当的容量。c.size()返回容器中实际数据的个数。c1.swap(c2)swap(c1,c2)将c1和c2元素互换。同上操作。vector<Elem>cvector<Elem>c1(c2)vector<Elem>c(n)ector<Elem>c(n,elem)vector<Elem>c(beg,end)c.~vector<Elem>()创建一个空的vector。复制一个vector。创建一个vector，含有n个数据，数据均已缺省构造产生。创建一个含有n个elem拷贝的vector。创建一个以[beg;end)区间的vector。销毁所有数据，释放内存。operator[]返回容器中指定位置的一个引用。创建一个vectorvector容器提供了多种创建方法，下面介绍几种常用的。创建一个Widget类型的空的vector对象：vector<Widget>vWidgets;创建一个包含500个Widget类型数据的vector：vector<Widget>vWidgets(500);创建一个包含500个Widget类型数据的vector，并且都初始化为0：vector<Widget>vWidgets(500,Widget(0));创建一个Widget的拷贝：vector<Widget>vWidgetsFromAnother(vWidgets);向vector添加一个数据vector添加数据的缺省方法是push_back()。push_back()函数表示将数据添加到vector的尾部，并按需要来分配内存。例如：向vector<Widget>中添加10个数据，需要如下编写代码：for(inti=0;i<10;i++){vWidgets.push_back(Widget(i));}获取vector中制定位置的数据vector里面的数据是动态分配的，使用push_back()的一系列分配空间常常决定于文件或一些数据源。如果想知道vector存放了多少数据，可以使用empty()。获取vector的大小，可以使用size()。例如，如果想获取一个vectorv的大小，但不知道它是否为空，或者已经包含了数据，如果为空想设置为-1，你可以使用下面的代码实现：intnSize=v.empty()?-1:static_cast<int>(v.size());访问vector中的数据使用两种方法来访问vector。1、vector::at()2、vector::operator[]operator[]主要是为了与C语言进行兼容。它可以像C语言数组一样操作。但at()是我们的首选，因为at()进行了边界检查，如果访问超过了vector的范围，将抛出一个例外。由于operator[]容易造成一些错误，所有我们很少用它，下面进行验证一下：分析下面的代码：vector<int>v;v.reserve(10);for(inti=0;i<7;i++){v.push_back(i);}try{intiVal1=v[7];//notboundschecked-willnotthrowintiVal2=v.at(7);//boundschecked-willthrowifoutofrange}catch(constexception&e){cout<<e.what();}删除vector中的数据vector能够非常容易地添加数据，也能很方便地取出数据，同样vector提供了erase()，pop_back()，clear()来删除数据，当删除数据时，应该知道要删除尾部的数据，或者是删除所有数据，还是个别的数据。Remove_if()算法如果要使用remove_if()，需要在头文件中包含如下代码：：#include<algorithm>Remove_if()有三个参数：1、iterator_First：指向第一个数据的迭代指针。2、iterator_Last：指向最后一个数据的迭代指针。3、predicate_Pred：一个可以对迭代操作的条件函数。条件函数条件函数是一个按照用户定义的条件返回是或否的结果，是最基本的函数指针，或是一个函数对象。这个函数对象需要支持所有的函数调用操作，重载operator()()操作。remove_if()是通过unary_function继承下来的，允许传递数据作为条件。例如，假如想从一个vector<CString>中删除匹配的数据，如果字串中包含了一个值，从这个值开始，从这个值结束。首先应该建立一个数据结构来包含这些数据，类似代码如下：#include<functional>enumfindmodes{FM_INVALID=0,FM_IS,FM_STARTSWITH,FM_ENDSWITH,FM_CONTAINS};typedefstructtagFindStr{UINTiMode;CStringszMatchStr;}FindStr;typedefFindStr*LPFINDSTR;然后处理条件判断：classFindMatchingString:publicstd::unary_function<CString,bool>{public:FindMatchingString(constLPFINDSTRlpFS):m_lpFS(lpFS){}booloperator()(CString&szStringToCompare)const{boolretVal=false;switch(m_lpFS->iMode){caseFM_IS:{retVal=(szStringToCompare==m_lpFDD->szMatchStr);break;}caseFM_STARTSWITH:{retVal=(szStringToCompare.Left(m_lpFDD->szMatchStr.GetLength())==m_lpFDD->szWindowTitle);break;}caseFM_ENDSWITH:{retVal=(szStringToCompare.Right(m_lpFDD->szMatchStr.GetLength())==m_lpFDD->szMatchStr);break;}caseFM_CONTAINS:{retVal=(szStringToCompare.Find(m_lpFDD->szMatchStr)!=-1);break;}}returnretVal;}private:LPFINDSTRm_lpFS;};通过这个操作你可以从vector中有效地删除数据：FindStrfs;fs.iMode=FM_CONTAINS;fs.szMatchStr=szRemove;vs.erase(std::remove_if(vs.begin(),vs.end(),FindMatchingString(&fs)),vs.end());Remove(),remove_if()等所有的移出操作都是建立在一个迭代范围上的，不能操作容器中的数据。所以在使用remove_if()，实际上操作的时容器里数据的上面的。看到remove_if()实际上是根据条件对迭代地址进行了修改，在数据的后面存在一些残余的数据，那些需要删除的数据。剩下的数据的位置可能不是原来的数据，但他们是不知道的。调用erase()来删除那些残余的数据。注意上面例子中通过erase()删除remove_if()的结果和vs.enc()范围的数据。

媒介（vector）是指受到污染并将病原体传播给易感动物的各种外界因素。

1.vector 的数据的存入和输出：#include<stdio.h>#include<vector>#include <iostream>using namespace std;void main(){ int i = 0; vector<int> v; for( i = 0; i < 10; i++ ) { v.push_back( i );//把元素一个一个存入到vector中 } /* v.clear()*/ 对存入的数据清空for( i = 0; i < v.size(); i++ )//v.size() 表示vector存入元素的个数 { cout << v[ i ] << " "; //把每个元素显示出来 } cont << endl;} 注：你也可以用v.begin()和v.end() 来得到vector开始的和结束的元素地址的指针位置。你也可以这样做：vector<int>::iterator iter; /*iterator 抽象了指针的绝大部分基本特征*/for( iter = v.begin(); iter != v.end(); iter++ ) { cout << *iter << endl;}2. 对于二维vector的定义。1)定义一个10个vector元素，并对每个vector符值1-10。#include<stdio.h>#include<vector>#include <iostream>using namespace std;void main(){ int i = 0, j = 0;//定义一个二维的动态数组，有10行，每一行是一个用一个vector存储这一行的数据。所以每一行的长度是可以变化的。之所以用到vector<int>(0)是对vector初始化，否则不能对vector存入元素。 vector< vector<int> > Array( 10, vector<int>(0) ); for( j = 0; j < 10; j++ ) { for ( i = 0; i < 9; i++ ) { Array[ j ].push_back( i ); } } for( j = 0; j < 10; j++ ) { for( i = 0; i < Array[ j ].size(); i++ ) { cout << Array[ j ][ i ] << " "; } cout<< endl; }}2)定义一个行列都是变化的数组。#include<stdio.h>#include<vector>#include <iostream>using namespace std;void main(){ int i = 0, j = 0; vector< vector<int> > Array; vector< int > line; for( j = 0; j < 10; j++ ) { Array.push_back( line );//要对每一个vector初始化，否则不能存入元素。 for ( i = 0; i < 9; i++ ) { Array[ j ].push_back( i ); } } for( j = 0; j < 10; j++ ) { for( i = 0; i < Array[ j ].size(); i++ ) { cout << Array[ j ][ i ] << " "; } cout<< endl; }}使用 vettor erase 指定元素#include "iostream"#include "vector"using namespace std;int main(){ vector<int> arr; arr.push_back(6); arr.push_back(8); arr.push_back(3); arr.push_back(8); for(vector<int>::iterator it=arr.begin(); it!=arr.end(); ) { if(* it == 8) { it = arr.erase(it); } else { ++it; } } cout << "After remove 8: "; for(vector<int>::iterator it = arr.begin(); it < arr.end(); ++it) { cout << * it << " "; } cout << endl;}#include <iostream>#include <algorithm>#include <functional>#include <vector>using namespace std;void main(){int iarray[]={0,1,2,3,4,5,6,6,6,7,8};vector<int> ivector(iarray,iarray+sizeof(iarray)/sizeof(int));int iarray1[]={6,6};vector<int> ivector1(iarray1,iarray1+sizeof(iarray1)/sizeof(int)); int iarray2[]={5,6};vector<int> ivector2(iarray2,iarray2+sizeof(iarray2)/sizeof(int));int iarray3[]={0,1,2,3,4,5,7,7,7,9,7};vector<int> ivector3(iarray3,iarray3+sizeof(iarray3)/sizeof(int));//找出ivector之中相邻元素值相等的第一个元素cout<<*adjacent_find(ivector.begin(),ivector.end())<<endl;//找出ivector之中元素值为6的元素个数cout<<count(ivector.begin(),ivector.end(),6)<<endl;//找出ivector之中小于7的元素个数cout<<count_if(ivector.begin(),ivector.end(),bind2nd(less<int>(),7))<<endl;//找出ivector之中元素值为4的第一个元素所在位置的元素cout<<*find(ivector.begin(),ivector.end(),4)<<endl;//找出ivector之中大于2的第一个元素所在位置的元素cout<<*find_if(ivector.begin(),ivector.end(),bind2nd(greater<int>(),2))<<endl; //找出ivector之中子序列ivector1所出现的最后一个位置，再往后3个位置的元素cout<<*(find_end(ivector.begin(),ivector.end(),ivector1.begin(),ivector1.end())+3)<<endl;//找出ivector之中子序列ivector1所出现的第一个位置，再往后3个位置的元素cout<<*(find_first_of(ivector.begin(),ivector.end(),ivector1.begin(),ivector1.end())+3)<<endl; //子序列ivector2在ivector中出现的起点位置元素cout<<*search(ivector.begin(),ivector.end(),ivector2.begin(),ivector2.end())<<endl;//查找连续出现3个6的起点位置元素cout<<*search_n(ivector.begin(),ivector.end(),3,6,equal_to<int>())<<endl;//判断两个区间ivector和ivector3相等否(0为假，1为真）cout << equal(ivector.begin(), ivector.end(), ivector3.begin()) << endl;//查找区间ivector3在ivector中不匹配点的位置pair<int*,int*>result=mismatch(ivector.begin(),ivector.end(),ivector3.begin());cout<< result.first - ivector.begin() << endl; }#include <iostream>#include <algorithm>#include <functional>#include <vector>using namespace std;class even_by_two{ //类定义形式的函数对象public:int operator()() const{return _x+=2;}private:static int _x;};int even_by_two::_x=0; //静态数据成员初始化void main(){int iarray[]={0,1,2,3,4,5,6,6,6,7,8};int iarray1[]={0,1,2,3,4,4,5,5,6,6,6,6,6,7,8};vector<int> ivector(iarray,iarray+sizeof(iarray)/sizeof(int));vector<int> ivector1(iarray+6,iarray+8); vector<int> ivector2(iarray1,iarray1+sizeof(iarray1)/sizeof(int));ostream_iterator< int > output( cout, " " ); //定义流迭代器用于输出数据//迭代遍历ivector1区间，对每一个元素进行even_by_two操作 generate(ivector1.begin(),ivector1.end(),even_by_two());copy(ivector1.begin(),ivector1.end(),output);cout<<endl;//迭代遍历ivector的指定区间（起点和长度），对每一个元素进行even_by_two操作 generate_n(ivector.begin(),3,even_by_two());copy(ivector.begin(),ivector.end(),output);cout<<endl;//删除元素6 remove(ivector.begin(),ivector.end(),6);copy(ivector.begin(),ivector.end(),output);cout<<endl; //删除(实际并未从原序列中删除）元素6，结果置于另一个区间 vector<int> ivector3(12);remove_copy(ivector.begin(),ivector.end(),ivector3.begin(),6);copy(ivector3.begin(),ivector3.end(),output);cout<<endl;//删除(实际并未从原序列中删除）小于6的元素remove_if(ivector.begin(),ivector.end(),bind2nd(less<int>(),6));copy(ivector.begin(),ivector.end(),output);cout<<endl; //删除(实际并未从原序列中删除)小于7的元素，结果置于另一个区间，remove_copy_if(ivector.begin(),ivector.end(),ivector3.begin(),bind2nd(less<int>(),7));copy(ivector3.begin(),ivector3.end(),output);cout<<endl; //将所有的元素值6，改为元素值3replace(ivector.begin(),ivector.end(),6,3);copy(ivector.begin(),ivector.end(),output);cout<<endl; //将所有的元素值3，改为元素值5,结果放置到另一个区间replace_copy(ivector.begin(),ivector.end(),ivector3.begin(),3,5);copy(ivector3.begin(),ivector3.end(),output);cout<<endl; //将所有小于5的元素值，改为元素值2replace_if(ivector.begin(),ivector.end(),bind2nd(less<int>(),5),2);copy(ivector.begin(),ivector.end(),output);cout<<endl; //将所有的元素值8，改为元素值9,结果放置到另一个区间replace_copy_if(ivector.begin(),ivector.end(),ivector3.begin(),bind2nd(equal_to<int>(),8),9);copy(ivector3.begin(),ivector3.end(),output);cout<<endl; //逆向重排每一个元素reverse(ivector.begin(),ivector.end());copy(ivector.begin(),ivector.end(),output);cout<<endl; //逆向重排每一个元素,结果置于另一个区间reverse_copy(ivector.begin(),ivector.end(),ivector3.begin());copy(ivector3.begin(),ivector3.end(),output);cout<<endl; //旋转（互换元素）[first,middle), 和[middle,end)rotate(ivector.begin(),ivector.begin()+4,ivector.end());copy(ivector.begin(),ivector.end(),output);cout<<endl; //旋转（互换元素）[first,middle], 和[middle,end]，结果置于另一个区间，rotate_copy(ivector.begin(),ivector.begin()+5,ivector.end(),ivector3.begin());copy(ivector3.begin(),ivector3.end(),output);cout<<endl; }#include <iostream>#include <algorithm>#include <functional>#include <vector>using namespace std;void main(){int iarray[]={26,17,15,22,23,33,32,40};vector<int> ivector(iarray,iarray+sizeof(iarray)/sizeof(int));// 查找并输出最大、最小值元素cout<<*max_element(ivector.begin(),ivector.end())<<endl;cout<<*min_element(ivector.begin(),ivector.end())<<endl;//将ivector.begin()+4-ivector.begin()各元素排序，//放进[ivector.begin(),ivector.begin()+4]区间。剩余元素不保证维持原来相对次序partial_sort(ivector.begin(),ivector.begin()+3,ivector.end());copy(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));cout<<endl;//局部排序并复制到别处vector<int> ivector1(5);partial_sort_copy(ivector.begin(),ivector.end(),ivector1.begin(),ivector1.end());copy(ivector1.begin(),ivector1.end(),ostream_iterator<int>(cout," "));cout<<endl;//排序，缺省为递增。sort(ivector.begin(),ivector.end());copy(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));cout<<endl;//将指定元素插入到区间内不影响区间原来排序的最低、最高位置cout<<*lower_bound(ivector.begin(),ivector.end(),24)<<endl;cout<<*upper_bound(ivector.begin(),ivector.end(),24)<<endl;//对于有序区间，可以用二分查找方法寻找某个元素 cout<<binary_search(ivector.begin(),ivector.end(),33)<<endl; cout<<binary_search(ivector.begin(),ivector.end(),34)<<endl;//下一个排列组合next_permutation(ivector.begin(),ivector.end());copy(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));cout<<endl;//上一个排列组合prev_permutation(ivector.begin(),ivector.end());copy(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));cout<<endl;//合并两个序列ivector和ivector1，并将结果放到ivector2中vector<int> ivector2(13);merge(ivector.begin(),ivector.end(),ivector1.begin(),ivector1.end(),ivector2.begin());copy(ivector2.begin(),ivector2.end(),ostream_iterator<int>(cout," "));cout<<endl;//将小于*(ivector.begin()+5)的元素放置在该元素之左//其余置于该元素之右。不保证维持原有的相对位置nth_element(ivector2.begin(),ivector2.begin()+5,ivector2.end());copy(ivector2.begin(),ivector2.end(),ostream_iterator<int>(cout," "));cout<<endl;//排序，并保持原来相对位置stable_sort(ivector2.begin(),ivector2.end());copy(ivector2.begin(),ivector2.end(),ostream_iterator<int>(cout," "));cout<<endl;//针对一个有序区间，找出其中一个子区间，其中每个元素都与某特定元素值相同pair<vector<int>::iterator,vector<int>::iterator> pairIte;pairIte=equal_range(ivector2.begin(),ivector2.end(),22);cout<<*(pairIte.first)<<endl; cout<<*(pairIte.second)<<endl;//合并两个有序序列，然后就地替换int iarray3[] = { 1, 3, 5, 7, 2, 4, 6, 8 };vector<int> ivector3(iarray3,iarray3+sizeof(iarray3)/sizeof(int));inplace_merge(ivector3.begin(), ivector3.begin()+ 4, ivector3.end());copy(ivector3.begin(),ivector3.end(), ostream_iterator<int>(cout, " ")); cout<<endl; //以字典顺序比较序列ivector3和ivector4int iarray4[] = { 1, 3, 5, 7,1, 5, 9, 3 };vector<int> ivector4(iarray4,iarray4+sizeof(iarray4)/sizeof(int));cout<< lexicographical_compare(ivector3.begin(),ivector3.end(),ivector4.begin(),ivector4.end()) << endl}

定义了一个vector二维向量，其中每个元素都是vector<int>,意思就是，定义了n个int类型的vector向量。这样就好理解了。

貌似你的理解有错误而且 C# 中的 Vector 也没有 Value 属性

(1)Vector比ArrayList先存在。Vector是同步的，Vector的对象是线程安全的；ArrayList是异步的，ArrayList的对象不是线程安全的。同步影响执行效率，所以ArrayList比Vector性能好。(2)ArrayList和Vector都有一个初始的容量大小，当存储的空间不够时，需要增加存储空间，Vector默认增长原来的一倍，而ArrayList是原来的0.5倍。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小。

每个vector存储一个一维的数组，这个好理解，那么再用一个vector，这个vector每一个元素存储一个一维数组的vector，所以就是二维的了。vector<vector<int> > matrix(row,vector<int>(col,0));这个代码的含义是：vector<vector<int> >外层的vector就是那个用于存储vector的，是第二维，它包含row个一维的vector，而每一个一维的vector包含col个int。后面的matrix里面是调用了vector的构造函数进行这个结构的构造。

用类和模板技术实现的。

1、vector是一个构造对象，不能直接使用=符号进行复制，必须迭代每个元素来复制。或者重载=操作符。2、大致有一下几种方法实现用于把一个vector复制给另一个vector：方法1：vector<int > v1(v2);//声明方法2：使用swap进行赋值：vector<int > v1();v1.swap(v2);//将v2赋值给v1，此时v2变成了v1方法3：使用函数assign进行赋值：vector<int > v1;//声明v1v1.assign(v2.begin(), v2.end());//将v2赋值给v1方法4：使用循环语句赋值，效率较差vector<int >::iterator it;//声明迭代器for(it = v2.begin();it!=v2.end();++it){//遍历v2,赋值给v1v1.push_back(it);}

形象点说就是封装成类一个顺序表

vector容器类型 vector容器是一个模板类，可以存放任何类型的对象（但必须是同一类对象）。vector对象可以在运行时高效地添加元素，并且vector中元素是连续存储的。vector的构造函数原型：template<typename T> explicit vector(); // 默认构造函数，vector对象为空 explicit vector(size_type n, const T& v = T()); // 创建有n个元素的vector对象 vector(const vector& x); vector(const_iterator first, const_iterator last);注：vector容器内存放的所有对象都是经过初始化的。如果没有指定存储对象的初始值，那么对于内置类型将用0初始化，对于类类型将调用其默认构造函数进行初始化（如果有其它构造函数而没有默认构造函数，那么此时必须提供元素初始值才能放入容器中）。举例：vector<string> v1; // 创建空容器，其对象类型为string类vector<string> v2(10); // 创建有10个具有初始值（即空串）的string类对象的容器vector<string> v3(5, "hello"); // 创建有5个值为“hello”的string类对象的容器vector<string> v4(v3.begin(), v3.end()); // v4是与v3相同的容器（完全复制）vector的操作（下面的函数都是成员函数）bool empty() const; // 如果为容器为空，返回true；否则返回falsesize_type max_size() const; // 返回容器能容纳的最大元素个数size_type size() const; // 返回容器中元素个数 size_type capacity() const; // 容器能够存储的元素个数，有：capacity() >= size() void reserve(size_type n); // 确保capacity() >= nvoid resize(size_type n, T x = T()); // 确保返回后，有：size() == n；如果之前size()<n，那么用元素x的值补全。reference front(); // 返回容器中第一个元素的引用（容器必须非空）const_reference front() const; reference back(); // 返回容器中最后一个元素的引用（容器必须非空）const_reference back() const;reference operator[](size_type pos); // 返回下标为pos的元素的引用（下标从0开始；如果下标不正确，则属于未定义行为。const_reference operator[](size_type pos) const; reference at(size_type pos); // 返回下标为pos的元素的引用；如果下标不正确，则抛出异常out_of_rangeconst_reference at(size_type pos) const;void push_back(const T& x); // 向容器末尾添加一个元素 void pop_back(); // 弹出容器中最后一个元素（容器必须非空）// 注：下面的插入和删除操作将发生元素的移动（为了保持连续存储的性质），所以之前的迭代器可能失效iterator insert(iterator it, const T& x = T()); // 在插入点元素之前插入元素（或者说在插入点插入元素）void insert(iterator it, size_type n, const T& x); // 注意迭代器可能不再有效（可能重新分配空间）void insert(iterator it, const_iterator first, const_iterator last);iterator erase(iterator it); // 删除指定元素，并返回删除元素后一个元素的位置（如果无元素，返回end()）iterator erase(iterator first, iterator last); // 注意：删除元素后，删除点之后的元素对应的迭代器不再有效。void clear() const; // 清空容器，相当于调用erase( begin(), end())void assign(size_type n, const T& x = T()); // 赋值，用指定元素序列替换容器内所有元素void assign(const_iterator first, const_iterator last);const_iterator begin() const; // 迭代序列iterator begin();const_iterator end() const;iterator end();const_reverse_iterator rbegin() const;reverse_iterator rbegin();const_reverse_iterator rend() const; reverse_iterator rend();vector对象的比较（非成员函数） 针对vector对象的比较有六个比较运算符：operator==、operator!=、operator<、operator<=、operator>、operator>=。 其中，对于operator==和operator!=，如果vector对象拥有相同的元素个数，并且对应位置的元素全部相等，则两个vector对象相等；否则不等。 对于operator<、operator<=、operator>、operator>=，采用字典排序策略比较。注：其实只需要实现operator==和operator!=就可以了，其它可以根据这两个实现。因为，operator!= (lhs, rhs) 就是 !(lhs == rhs)，operator<=(lhs, rhs) 就是 !(rhs < lhs)，operator>(lhs, rhs) 就是 (rhs < lhs)，operator>=（lhs, rhs) 就是 !(lhs, rhs)。vector类的迭代器 vector类的迭代器除了支持通用的前缀自增运算符外，还支持算术运算：it + n、it - n、it2 - it1。注意it2 - it1返回值为difference_type（signed类型）。 注意，任何改变容器大小的操作都可能造成以前的迭代器失效。应用示例#include <iostream>#include <cassert>#include <vector>using namespace std;int main(){ vector<string> v(5, "hello"); vector<string> v2(v.begin(), v.end()); assert(v == v2); cout<<"> Before operation"<<endl; for(vector<string>::const_iterator it = v.begin(); it < v.end(); ++it) cout<<*it<<endl; v.insert(v.begin() + 3, 4, "hello, world"); cout<<"> After insert"<<endl; for(vector<string>::size_type i = 0; i < v.size(); ++i) cout<<v[i]<<endl; vector<string>::iterator it = v.erase(v.begin() + 3, v.begin() + 6); assert(*it == "hello, world"); cout<<"> After erase"<<endl; for(vector<string>::size_type i = 0; i != v.size(); ++i) cout<<v[i]<<endl; assert(v.begin() + v.size() == v.end()); assert(v.end() - v.size() == v.begin()); assert(v.begin() - v.end() == -vector<string>::difference_type(v.size())); return 0;}程序说明：上面程序中用了三个循环输出容器中的元素，每个循环的遍历方式是不一样的。特别需要说明的是，第二个循环在条件判断中使用了size() 函数，而不是在循环之前先保存在变量中再使用。之所以这样做，有两个原因：其一，如果将来在修改程序时，在循环中修改了容器元素个数，这个循环仍然能很好 地工作，而如果先保存size()函数值就不正确了；其二，由于这些小函数（其实现只需要一条返回语句）基本上都被声明为inline，所以不需要考虑效率问题。在网上找的 还有很多 建议你还是买一本stl看看里面有更详细的内容 而且比较基础

你是想要直方图还是polygon啊，polygon是多边形，直方图里不可能有多边形吧。hist只是柱状图hist(x)，其中x是个vector，如x=c(1,2,3)你的CVS表格里的数据格式是怎么样的？根据提示的错误，应该是文件格式问题。如果格式没问题，先把d2转成矩阵，再转成vector，就可以

java中vector和数据非常类似，两者之间也经常成对出现，下面是两者的比较：1、数组：javaarrays的元素个数不能下标越界，从很大程度上保证了java程序的安全性，但创建时必须指定数组的大小，并不能再改变。2、vector：对比于array，当更多的元素被加入进来以至超出其容量时，vector的size会动态增长，而array容量是定死的。同时，vector在删除一些元素后，其所有下标大于被删除元素的元素都依次前移，并获得新下标比原来的小了）。

C语言不能用vector，但你可以自己写个随机访问ADT或链表ADT

vector容器类型 vector容器是一个模板类，可以存放任何类型的对象（但必须是同一类对象）。vector对象可以在运行时高效地添加元素，并且vector中元素是连续存储的。vector的构造函数原型：template<typename T> explicit vector(); // 默认构造函数，vector对象为空 explicit vector(size_type n, const T& v = T()); // 创建有n个元素的vector对象 vector(const vector& x); vector(const_iterator first, const_iterator last);注：vector容器内存放的所有对象都是经过初始化的。如果没有指定存储对象的初始值，那么对于内置类型将用0初始化，对于类类型将调用其默认构造函数进行初始化（如果有其它构造函数而没有默认构造函数，那么此时必须提供元素初始值才能放入容器中）。举例：vector<string> v1; // 创建空容器，其对象类型为string类vector<string> v2(10); // 创建有10个具有初始值（即空串）的string类对象的容器vector<string> v3(5, "hello"); // 创建有5个值为“hello”的string类对象的容器vector<string> v4(v3.begin(), v3.end()); // v4是与v3相同的容器（完全复制）vector的操作（下面的函数都是成员函数）bool empty() const; // 如果为容器为空，返回true；否则返回falsesize_type max_size() const; // 返回容器能容纳的最大元素个数size_type size() const; // 返回容器中元素个数 size_type capacity() const; // 容器能够存储的元素个数，有：capacity() >= size() void reserve(size_type n); // 确保capacity() >= nvoid resize(size_type n, T x = T()); // 确保返回后，有：size() == n；如果之前size()<n，那么用元素x的值补全。

1、首先需要打开软件如红框勾选所示，构造一个int类型的vector向量。2、程序运行结果如图，可以看到vector的size为0。3、如红框勾选所示，将vector元素的值修改为6个元素值为20的vector向量。4、运行结果显示，成功的构造了6个元素为20的向量。5、如图所示，以现有vector对象的范围作为构造函数的参数，同样也将对象复制给另一个vector对象。6、程序运行结果如图所示结果确实显示为4个20。

#include <iostream>#include <vector>using namespace std;int main(){ vector<int> vec; for (int i = 0; i < 5; ++i) vec.push_back(i); vector<int>::reverse_iterator it; for (it = vec.rbegin(); it != vec.rend(); it++) cout<<*it<<" "; cout<<endl;}

vector容器类型x0dx0a vector容器是一个模板类，可以存放任何类型的对象（但必须是同一类对象）。vector对象可以在运行时高效地添加元素，并且vector中元素是连续存储的。x0dx0avector的构造x0dx0a x0dx0a函数原型：x0dx0atemplatex0dx0a explicit vector(); // 默认构造函数，vector对象为空x0dx0a explicit vector(size_type n, const T& v = T()); // 创建有n个元素的vector对象x0dx0a vector(const vector& x);x0dx0a vector(const_iterator first, const_iterator last);x0dx0ax0dx0a注：vector容器内存放的所有对象都是经过初始化的。如果没有指定存储对象的初始值，那么对于内置类型将用0初始化，对于类类型将调用其默认构造函数进行初始化（如果有其它构造函数而没有默认构造函数，那么此时必须提供元素初始值才能放入容器中）。x0dx0a x0dx0a举例：x0dx0avector v1; // 创建空容器，其对象类型为string类x0dx0avector v2(10); // 创建有10个具有初始值（即空串）的string类对象的容器x0dx0avector v3(5, "hello"); // 创建有5个值为“hello”的string类对象的容器x0dx0avector v4(v3.begin(), v3.end()); // v4是与v3相同的容器（完全复制）x0dx0a x0dx0avector的操作（下面的函数都是成员函数）x0dx0a x0dx0abool empty() const; // 如果为容器为空，返回true；否则返回falsex0dx0asize_type max_size() const; // 返回容器能容纳的最大元素个数x0dx0asize_type size() const; // 返回容器中元素个数 x0dx0asize_type capacity() const; // 容器能够存储的元素个数，有：capacity() >= size() x0dx0avoid reserve(size_type n); // 确保capacity() >= nx0dx0avoid resize(size_type n, T x = T()); // 确保返回后，有：size() == n；如果之前size()、operator>=。x0dx0a x0dx0a 其中，对于operator==和operator!=，如果vector对象拥有相同的元素个数，并且对应位置的元素全部相等，则两个vector对象相等；否则不等。x0dx0a 对于operator<、operator<=、operator>、operator>=，采用字典排序策略比较。x0dx0ax0dx0a注：其实只需要实现operator==和operator!=就可以了，其它可以根据这两个实现。因为，operator!= (lhs, rhs) 就是 !(lhs == rhs)，operator<=(lhs, rhs) 就是 !(rhs < lhs)，operator>(lhs, rhs) 就是 (rhs < lhs)，operator>=（lhs, rhs) 就是 !(lhs, rhs)。x0dx0a x0dx0avector类的迭代器x0dx0ax0dx0a vector类的迭代器除了支持通用的前缀自增运算符外，还支持算术运算：it + n、it - n、it2 - it1。注意it2 - it1返回值为difference_type（signed类型）。x0dx0a x0dx0a 注意，任何改变容器大小的操作都可能造成以前的迭代器失效。x0dx0a x0dx0a应用示例x0dx0a x0dx0a#include x0dx0a#include x0dx0a#include x0dx0ax0dx0ausing namespace std;x0dx0ax0dx0aint main()x0dx0a{x0dx0a vector v(5, "hello");x0dx0a vector v2(v.begin(), v.end());x0dx0a x0dx0a assert(v == v2);x0dx0a x0dx0a cout<<"> Before operation"<::const_iterator it = v.begin(); it < v.end(); ++it)x0dx0a cout<<*it< After insert"<::size_type i = 0; i < v.size(); ++i)x0dx0a cout<::iterator it = v.erase(v.begin() + 3, v.begin() + 6);x0dx0a assert(*it == "hello, world");x0dx0a cout<<"> After erase"<::size_type i = 0; i != v.size(); ++i)x0dx0a cout<::difference_type(v.size()));x0dx0a x0dx0a return 0;x0dx0a}x0dx0a程序说明：上面程序中用了三个循环输出容器中的元素，每个循环的遍历方式是不一样的。特别需要说明的是，第二个循环在条件判断中使用了size() 函数，而不是在循环之前先保存在变量中再使用。之所以这样做，有两个原因：其一，如果将来在修改程序时，在循环中修改了容器元素个数，这个循环仍然能很好 地工作，而如果先保存size()函数值就不正确了；其二，由于这些小函数（其实现只需要一条返回语句）基本上都被声明为inline，所以不需要考虑效率问题。x0dx0a在网上找的 还有很多 建议你还是买一本stl看看里面有更详细的内容 而且比较基础

　　vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。　　vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。　　为了可以使用vector，必须在你的头文件中包含下面的代码：　　#include <vector>　　vector属于std命名域的，因此需要通过命名限定，如下完成你的代码：　　using std::vector;　　vector<int> vInts;　　或者连在一起，使用全名：　　std::vector<int> vInts;　　建议在代码量不大，并且使用的命名空间不多的情况下，使用全局的命名域方式：using namespace std;

向量在Unity的含义在Unity中最常用的类就是Vector3这个类了，简单的说是向量，实际上远非如此。在Unity中Vector3有一下几种含义1. 三个数字打一包：这种用法没有几何意义，就是三个数，没其他的。比如欧拉角，缩放比例，都是这样的用法，这种情况不能看成是向量。所以对这种用法做向量运算的话结果可能会很奇怪。2. 空间位置的“点”：关键词是“点”，这种情况用的最多的是transform.Position，它表示的是位置，与x，y，z坐标对应，在某些计算下有集合含义，可以做运算。3. 空间位置的“方向线段”：方向线段这才是向量真正的姿态，一个向量有两个含义：大小和方向，所以向量可以拆分成两部分来看，大小就是模（|v|），方向就是标准化(Vn)，例如描述一个朝Vn方向大小为|v|的速度。这里有一个隐藏属性，就是从原点（0,0,0）出发。两点一线。所以向量可以分解为v=|v|* Vn向量和常数(i)的运算：不能加减。iV=Vi=(ix,iy,iz) 满足交换律。代表把线拉长多少倍V/i = (x/i, y/i, z/i) 注意 i/V是不行的。代表把线缩小多少倍向量的常用运算和意义：1. 向量的长度（模|v|）注意只有当做”方向线段“的时候模才有意义，简单的说就是这条线有多长，就是你用尺子量出来的数据。公式： 脚本：v.magnitude，v.sqrMagnitudesqrMagnitude代表模的平方，为啥会有这么个东西呢？其实仅仅是因为平方根的计算会很耗时，sqrMagnitude的效率会高很多，例如在比较模的大小这类的问题上，比较sqrMagnitude的大小就足够了。2. 向量的标准化（单位向量 Vn）同样，是对“方向线段”的描述, 意思是把这条线拉长或者缩短，让他的模等于1，他最大的作用就是表示方向，判断两个向量是不是一个方向，判断Vn就可以了。公式：脚本：v.normalized， v.Normalize()使用技巧：如要把任意V长度变成5，直接5*Vn就可以了v.normalized是计算自己标准后的向量，然后返回别处用，自己的值不会改变。v.Normalize()是把自己标准化，自己的值会改变。3. 向量相加（Va+Vb）看做“方向线段”可以用来表示路径，速度等的叠加。例如：走到a点再走到b点的结果。先以速度a出发再受到速度b的结果。公式：脚本: 直接写Va+Vb4. 向量相减（Va-Vb）看做“点”时表示:将两点连成方向线段，方向由b指向a。如此一来要计算两点之间的距离和相对方向就很容易了，距离是|Va-Vb|, 相对方向是Va-Vb再标准化。这个很实用看做“方向线段”可以用来求速度，路径等的逆运算，回滚等。公式：脚本: 直接写Va-Vb5. 向量点乘（Va.Vb）具体含义比较模糊代表，在物理学中，已知力与位移，点乘的结果为功, 看做“方向线段”可以用来求夹角，个人感觉这是最有用的地方。公式： 注意结果是一个常数脚本: Vector3.Dot(va, vb)实用技巧：，可以直接得到夹角，比较好的是Unity提供了这个方法Vector3.Angle(Va, Vb)。6. 向量叉乘（Va x Vb）这个感觉很少用，我也几乎没用过，坐等大神来解答脚本: Vector3. Cross (va, vb)7. 投影（Vp）V在轴Vb上的影子, 这个概念不好说清楚，可以去问度娘，可以用来做向量的切割，比如要限制物体的运动方向时可以使用投影。公式：脚本: Vector3.Project(V, Vb);8. 反射（Vr）V对于法线N的反射，这个最有意思了，想想一下光反射或者桌球反弹，就是那个概念。可以用于模拟一下物理碰撞。公式： 注意此处N需要标准化脚本: Vector3. Reflect (V, N);

定义一个整形vector引用变量

#include <iostream>#include <vector>using namespace std;int main(){ vector<int> vec; for (int i = 0; i < 5; ++i) vec.push_back(i); vector<int>::reverse_iterator it; for (it = vec.rbegin(); it != vec.rend(); it++) cout<<*it<<" "; cout<<endl;}

vehicle和vector的区别：意思不同：vehicle意为“车辆、工具、交通工具、运载工具、传播媒介、媒介物。”，而vector的意思是：“向量、矢量、带菌者、无线电导。”。

a/b/c 中的a和c 是什么意思？

#include <iostream>#include <vector>using namespace std;int main(void){ typedef vector<int> VECINT; //1、new一个vector，vector里有10个int元素，输出第五个元素的值，然后释放内存。 VECINT *vec = new VECINT; cout << vec->at(4) << endl; delete vec; //2、new十个vector，每个vector有十个int元素，输出第五个vector的第五个元素的值，然后释放内存。 VECINT *vect = new VECINT [10]; cout << (vect + 4)->at(5) << endl; delete [] vect; system("PAUSE"); return 0;}

vector可以理解为变长数组;常见操作：std::vector<int> vecCase;vecCase.push_back(**);vecCase.size();vecCase.empty();vecCase.erase(***);vecCase.insert(**);vecCase.pop_back();vecCase.begin();vecCase.end();

张量积(tensor product) ，可以应用于不同的上下文中如向量、矩阵、张量、向量空间、代数、拓扑向量空间和模。在各种情况下这个符号的意义是同样的: 最一般的双线性运算。在某些上下文中也叫做外积。tensor是矩阵分析里面的张量，表示高维数组，或者叫多路数据。二阶张量就是矩阵，一阶张量就是向量。高阶SVD相对于矩阵SVD更能提取出高维数据的内在结构。 Vector 类在 java 中可以实现自动增长的对象数组; vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。 (1) 矢量：具有方向性的量。 (2) 编程语言方面：vector是C++标准模板库中的部分内容，中文偶尔译作“容器”，但并不准确。它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。

windowsTestwindowsTestinDebugwindowsTest.exe ..............................windowsTest.pdb ..............................windowsTest.vshost.exe ..............................windowsTest.vshost.exe.manifest .........................Debug .........................Release ......................in ......................DbfToTxt.cs ......................DbfToTxt.Designer.cs ......................DbfToTxt.resx ......................FolderNameEditor.cs ......................Form1.cs ......................Form1.Designer.cs ......................Form1.resx ......................Form2.cs ......................Form2.Designer.cs ......................Form2.resx ......................Form3.cs ......................Form3.Designer.cs ......................Form3.resx ......................Form4.cs ......................Form4.Designer.cs ......................Form4.resx ......................objx86DebugDesignTimeResolveAssemblyReferences.cache .................................DesignTimeResolveAssemblyReferencesInput.cache .................................GenerateResource.read.1.tlog .................................GenerateResource.write.1.tlog .................................ResolveAssemblyReference.cache .................................TempPE .................................windowsTest.csproj.FileListAbsolute.txt .................................windowsTest.DbfToTxt.resources .................................windowsTest.exe .................................windowsTest.Form1.resources .................................windowsTest.Form2.resources .................................windowsTest.Form3.resources .................................windowsTest.Form4.resources .................................windowsTest.pdb .................................windowsTest.Properties.Resources.resources ............................Debug .........................x86 ......................obj ......................Program.cs .........................pertiesAssemblyInfo.cs ................................Resources.Designer.cs ................................Resources.resx ................................Settings.Designer.cs ................................Settings.settings ......................Properties ......................StMessage.cs ......................windowsTest.csproj ...........windowsTest ...........windowsTest.sln ...........windowsTest.suo

区别不大，都是数列结构。c++不区分基础数据类型，所以vector可以直接作用于int,char这类基础类型vectorjava中vector必须作用于object的子类，需要用包装类vectorjava版的功能更全面一些。

#include“vector”是包含vector头文件的意思。vector是一种顺序容器，事实上和数组差不多，但它比数组更优越。一般来说数组不能动态拓展，因此在程序运行的时候不是浪费内存，就是造成越界。而vector正好弥补了这个缺陷，它的特征是相当于可分配拓展的数组，它的随机访问快，在中间插入和删除慢，但在末端插入和删除快，而且如果你用.at()访问的话，也可以做越界检查。

张量积(tensorproduct)，可以应用于不同的上下文中如向量、矩阵、张量、向量空间、代数、拓扑向量空间和模。在各种情况下这个符号的意义是同样的:最一般的双线性运算。在某些上下文中也叫做外积。tensor是矩阵分析里面的张量，表示高维数组，或者叫多路数据。二阶张量就是矩阵，一阶张量就是向量。高阶SVD相对于矩阵SVD更能提取出高维数据的内在结构。Vector类在java中可以实现自动增长的对象数组;vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。(1)矢量：具有方向性的量。(2)编程语言方面：vector是C++标准模板库中的部分内容，中文偶尔译作“容器”，但并不准确。它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。

vector<int> v;... ...reverse(v.begin(), v.end());

#include "Vector.h"

不能。。。vector 是C++的。。

v.erase(0,1);