vector

你好,为你解答,正确答案为：singular vector奇异向量不明白请及时追问，满意敬请采纳，O(∩_∩)O谢谢

singular vector_百度翻译singular vector [英]u02c8siu014bɡjulu0259 u02c8vektu0259 [美]u02c8su026au014bɡju0259lu025a u02c8vu025bktu025a 奇异向量 [例句]Recurving tropical cyclones :singular vector sensitivity and downstream impacts.向后弯热带气旋:奇异向量的敏感性和下游影响

请参照 thrust，一个CUDA SDK自带的库，它实现了和Vector类似的功能，有device_vector和host_vector。谢谢

穿梭载体(shuttle vector) 是指能在两种不同的生物中复制的载体，含有不止一个ori、能携带插入序列在不同种类宿主中繁殖，在原核生物和真核细胞中都能复制和表达。这类载体不仅具有细菌质粒的复制原点及选择标记基因，还有真核生物的自主复制序列(ARS) 以及选择标记性状，具有多克隆位点。通常穿梭载体在细菌中用于克隆，扩增克隆的基因在酵母菌中用于基因表达分析。基本简介例如既能在原核生物中复制,又能在真核生物中复制的载体。这类载体不仅具有细菌质粒的复制原点及选择标记基因，还有真核生物的自主复制序列(ARS)以及选择标记性状，具有多克隆位点。通常穿梭载体在细菌中用于克隆,扩增克隆的基因，在酵母菌中用于基因表达分析。

内联函数 就是编译时不传函数指针，直接将函数代码复制过去

Quaternion AnglesToQuaternion(const Vector3& Degrees){ Matrix3 mat3; mat3.FromEulerAnglesXYZ(Degree(Degrees.x), Degree(Degrees.y), Degree(Degrees.z)); Quaternion tmp; tmp.FromRotationMatrix(mat3); return tmp;}

很好用的，只是比国内其他的T载体贵。TAKARA的pMD 18-T Vector有通用的引物M13+和M13-（一般测序公司免费提供的），都可以进行测序的，随便选那个都可以。关键是看你的片段是多长，如果是600到1000BP之间，那就可以选M13+和M13-，让公司给你双向测之，（两段OVERLAP就可以测通你的片段）这样你就可以不用再设计测序引物了，节约费用。

　　“Stack extends Vector”从语义上意味着：堆栈是个向量 或者 堆栈属于向量。　　其实从现实生活中，并不会认为堆栈是从向量衍伸而来的，所以这种继承关系会让人从语义上觉得奇怪。　　有点像是：某人为了贪图方便，定义猴子的时候，直接从人类继承过来了；结果语义变成了 猴子属于人类。　　Effective java上说继承有自己的一些原则，但是显然栈并不是向量，所以栈不应该扩展向量。同样的，Properties不应该继承HashTable.这样回导致子类拥有一些父类的方法，逻辑奇怪也可能出现歧义。

这里我使用标准库里边的vector来对stack进行实现：入栈：即pust()，对应于vector里边的push_back()；出栈：即pop(),对应于vector里边的pop_back()；(标准库中的stack的成员函数pop()没有返回值，也就是说，不“把最后放入栈的object拿出来”，只移除最上面的元素------你上面的意思就是返回最上面的值，使用top()就行了）得到顶部元素：即top(),对应于vector里边的back();判断是否为空：即empty(),对应于vector里边的empty(),最大容量：vector里边有max_size()就返回的是最大容量，所以没有必要再设定一个属性来标记最大容量：// stack.h#include <iostream>#include <vector>template <typename Type>class stack {public: stack() : ele(vector<Type>()) { } void push(const Type& item) { if (size() < maxSize) ele.push_back(item); else std::cerr << "full, no more element can be pushed~" << " the max_size of this stack is " << maxSize << " : element " << item << " haven"t be pushed in stack" << std::endl; } Type pop() { Type temp(ele.back()); ele.pop_back(); return temp; } Type& top() { return ele.back(); } const Type& top() const { return ele.back(); } bool empty() const { return ele.empty(); } void set_max(size_t max) { maxSize = max; } size_t size() const { return ele.size(); } size_t max_size() const { erturn maxSize; } bool full() const { if (ele.size() == maxSize) return true; return false; }private: std::vector<Type> ele; size_t maxSize;};// main.cpp#include <iostream>#include "stack.h"using namespace std;int main(){ stack<int> x; x.push(4); cout << x.pop() << endl; x.set_max(5); for (int i = 0; i < 5; ++i) x.push(i); x.push(3); x.set_max(6); x.push(3); cout << x.top() << endl; if (x.full()) cout << "full" << endl; if (x.empty()) cout << "yes" << endl;}本来在stack::push()中不应该使用输出语句，最好使用异常如std::out_of_range最好，我写输出语句，只是为了更好的说明在栈满了之后就不能放入元素了，---我建议应该保持C++标准中stack的用法，没有full()，使用max_size()返回最大容量，你要判断栈是否满了（在程序外边用size()<max_size()即没满，否则就满了（或者溢出)~好了不说了，你看看程序吧，我睡觉了~晚安~

可以从Invitrogen 网站上下载了最新版的Vector NTI 11.5.3，安装正常，可以用原来的11.5 crack破解。我的系统是Windows 8.1，64位。

格式没有要求。因为你的软件是试用模式，所以导入功能还没有被激活而已。

invitrogen公司的一个TA克隆的质粒载体系列。看这里：http://tools.invitrogen.com/content/sfs/manuals/topota_man.pdf

(第三章)Unity3D-Vector3 - Kaven的专栏 - CSDN博客

原文链接 https://github.com/mapbox/vector-tile-spec/tree/master/2.1/ 在此文档中, 关于关键词【必须】、【禁止】、【必要的】、【应当】、【不应】、【推荐的】、【可以】与【可选的】的解释, 见 RFC 2119 中的描述。 此文档为矢量瓦片地理数据指定了一种节省空间的编码格式。 它被设计用于浏览器或服务器端应用程序，用于快速呈现或查找特征数据。 矢量瓦片格式使用 Google Protocol Buffers 编码格式. Protocol Buffers是一种与语言无关、与平台无关的可扩展序列化机制。 矢量瓦片文件的扩展名 应该 为 mvt . 例如 vector.mvt . When serving Vector Tiles the MIME type SHOULD be application/vnd.mapbox-vector-tile . 矢量瓦片表示一个整正方形范围内投影的数据。矢量瓦片 不应 包含关于边界和投影的信息。这个文件格式假定解码器在解码之前就已经知道投影和边界信息。 Web Mercator 是一个投影的参考, the Google tile scheme 是一个常见的范围参考. 它们一起提供了特定地理区域、特定细节级别和路径之间的一对一关系 ，例如 https://example.com/17/65535/43602.mvt . 矢量瓦片可以用任何投影和瓦片范围方案来表示数据。 这个规范描述了矢量瓦片的数据结构。 读者应该了解 矢量瓦片的protobuf的数据文档 及其定义的结构。 矢量瓦片由一组命名的层组成。每一层包含地理特征和它的元数据。层格式的设计使一层所需的数据在内存中是连续的，因此层可以添加到矢量瓦片中而不需要修改现有的数据。 一个实例瓦片 应该 至少包含一层。一层 应该 至少包含一个特征。 层 必须 包含 version 字段，此字段为图层所依赖矢量瓦片规范版本号的主版本号。例如，一个符合2.1版本规范的图层包含一个整数值为" 2 "的 version 字段。 version 字段 应该 是层中的第一个字段。 解码器 应该 首先解析 version ，以确保他们能够解码每一层。 当矢量瓦片用户遇到一个矢量瓦片层的未知版本时，它 可能 会尽最大努力尝试解释该层，或者跳过该层。 无论哪种情况，它都 应该 继续处理矢量瓦片中的后续图层 。 一个图层必须包含一个 name 字段. 一个实例瓦片 禁止 有两个或两个以上名字完全一样的图层.。在添加一个图层到现有的矢量瓦片之前，编码器 必须 检查现有的 name 字段，以防止重复。 层中的每个特征(见下文)都可以有一个或多个键值对作为元数据。 键和值是两个列表 keys 和 values 的索引，这两个列表是跨层特征共享的。 图层中 keys 字段中的每个元素为字符串。 keys 包含图层所用到的特征，每个键都可以通过它在这个集合中的位置来索引，索引从0开始。 keys 不应 包含两个完全一样的值。 图层中 values 字段中的每个元素为以下几种类型. values 表示图层中用到的所有特征的值，每个值都可以通过它在这个集合中的位置的来索引，索引从0开始。 values 不应 包含两个完全一样的值。 为了支持不同的string, boolean, integer, 和浮点型类型, value 字段的protobuf编码由一组 optional 字段组成。一个值必须包含这些可选字段中的一个。 一个图层必须包含一个 extent ， extent 通过整数坐标描述贴图的宽度和高度。通过定义 extent 瓦片内的几何图形 可以 延展出瓦片的范围，这样做通常是为了渲染一个跨越多个相邻瓦片的特征。 举例说明，如果一个瓦片的 extent 为 4096，这个瓦片的坐标单位为瓦片尺寸的1/4096。包含0的坐标在瓦片左侧或上侧的边缘。包含4096的坐标在瓦片右侧或下方的边缘。 1-4095的坐标完全在瓦片范围内，小于0或者大于4096的坐标完全在瓦片之外。 (1,10) 或 (4095,10) 完全在瓦片内，(0,10) 或 (4096,10) 在瓦片范围的边缘， (-1,10) 或 (4097,10)` 则完全在瓦片之外. feature 必须 包含一个 geometry 字段。 feature 必须 包含一个 type 字段，如果几何类型(Geometry Types)部分所属 feature 必须 包含一个 tags 字段，如果存在Feature-level metadata,他们 应该 存储在 tags 字段。 feature 必须 包含一个 id 字段。 如果feature包含 id 字段， id 的值 应该 在其所在的图层内保证唯一。 矢量瓦片的几何数据定义在一个屏幕坐标系中。瓦片的左上角为坐标系的原点（默认显示）。X轴正方向朝右，Y轴正方向朝下。几何 坐标 必须为整数。 每个几何图形被编码为32位无符号整数序列并存储在feature的 geometry 字段中。每个整数要么是 命令整数 CommandInteger 要么是参数整数 ParameterInteger . 解释器把它们解析为一系列有序操作，来生成模型。 命令中的位置是相对"cursor"的，"cursor"是一个可以重定义的点。 feature执行第一个命令时 cursor 在 坐标系的 (0,0) 位置。其他命令有可能移动cursor，去影响后续命令。 CommandInteger 中command ID，用来表示要执行的命令，command count 表示命令要执行的次数。 command ID 存储在 CommandInteger 的最低3位，取值范围为[0,7]，command count 存储在 CommandInteger 中剩下的29位, 取值范围[ 0 , pow(2, 29) - 1 ]. command ID, command count, CommandInteger 三者关系可由以下位操作表示： command ID用来表示以下命令: 命令用到的参数在 ParameterInteger 后面。 ParameterIntegers 的数量等于命令的参数个数乘以 CommandInteger 的command count。 比如, CommandInteger 有一个 MoveTo 命令，command count 为 3，那么在后面根6个 ParameterIntegers 。 ParameterInteger 采用 zigzag 编码，所以小的正数或者负数都会被编码成小整数。 parameter value转 ParameterInteger 公式为： Parameter values不支持 大于 pow(2,31) - 1 或者小于 -1 * (pow(2,31) - 1) 的值。 解码 ParameterInteger 的公式： 对所有命令的描述中，初始坐标记作 (cX, cY) ，即 cursor 的坐标。 MoveTo 命令的 command count 为 n ， 那么它后边必须跟随 n 对 ParameterInteger 。每对为 (dX, dY) : LineTo 命令的 command count 为 n ， 那么它后边必须跟随 n 对 ParameterInteger 。每对为 (dX, dY) : 任何 (dX, dY) 中 dX 和 dY 禁止 同时为 0 . ClosePath 命令command count 必须为 1 且不带 ParameterInteger 。此命令创建一个从cursor (cX, cY) 开始到起始点结束的线段，来完成POLYGON 几何图形中当前的线性环的绘制。 此命令不改变 cursor位置。 在feature中 type 字段来描述 geometry 的类型 ，其值为取自枚举 GeomType 。以下几何类型被支持： 不支持几何图形集合。 该规范有意留下一个未知的几何类型作为选项。 这种几何类型对编码器可以选择实现的实验几何类型进行编码。 这种几何类型可以作为实验性的类型被某些编码器所执行。解码器可能会忽略这种几何类型的任何特征。 POINT 类型，表示一个或多个点的几何图形。此类型的命令序列 必须 是一个command count大于0的 MoveTo 的命令。 如果 POINT 类型的 MoveTo 命令的command count 等于 1，那么该几何图形 一定 是一个单点，否则，几何图形必须被解释为多点几何图形，其中每一对 ParameterInteger 为一个单点。 LINESTRING 类型表示 单个线条的 linestring 或多线条组合的 multilinestring 几何图形。此类型的命令序列必须由以下一个或者多个重复的序列组成 ： 如果 LINESTRING 的命令序列只包含一个 MoveTo 命令，那么该图形一定被解释为单条线段的几何图形 ；否则，该几何图形一定被解释为多条线段组合的图形，每一个 MoveTo 命令表示新线条的起始点。 POLYGON 类型用来表示 单个多边形或这个组合多边形的几何图形, 每个多边形仅由一个外环组成，而外环又包含零个或多个内环。 此类型的命令序列必须由以下一个或者多个重复的序列组成 ： 每一个 ExteriorRing 和 InteriorRing 必须由以下序列组成： exterior ring 被定义为线性环，通过 计算公式 计算其面积为正数，在瓦片坐标系中(Y 轴正向朝下， X 轴正向朝右) 外环为顺时针顺序。 interior ring 被定义为线性环，通过 计算公式 计算其面积为负数，在瓦片坐标系中(Y 轴正向朝下， X 轴正向朝右) 外环为逆时针顺序。 如果一个 POLYGON 类型的命令序列中只有一个外环那么它一定被解释为一个多边形，否则它 一定 是一个多边形组合的图形，其每一个内环标示着一个新多边形的起点。如果一个多边形有内环，它们 必须 跟在它们所属的多边形的外环之后。 线性环 必须 是没有异常几何点的几何物体，如自交或自切。 在调用线性环的 ClosePath 命令之前，cursor的位置 不应 与线性环的第一个点重复，因为这会创建一个长度为0的线段。 线性环的面积 不应 为零，因为这意味着环上有异常的几何点。 多边形几何形状 不应 有任何内环相交，内环 必须 由外环包围。 表示一个点: 仅需要一条命令: 表示两个点分别位于: 这需要两条命令: 表示由以下点组成的Linestring: 这需要三条命令: 表示两个Linestring: 需要以下命令: 表示由以下点组成的多边形: 需要以下命令: 下边的示例 由两个多边形组成 ，其中一个有一个洞。多边形的顶点如下所示。多边形的顺序在这个例子中是 非常 重要的，因为它表示内环和新多边形之间的区别。 此多边形需要以下命令: 特征属性位于feature的 tag 字段，为成对的整数。每一对中的第一个整数为 layer 中 keys 的索引（从0开始），用来表示它属于此特征， 每一对中的第二个整数为 layer 中 values 的索引（从0开始），用来表示它属于此特征。每个键索引在该特性中 必须 是唯一的，这样该特性中的其他属性对就不会有相同的键索引。 一个特性必须有偶数个 tag 字段。特性 tag 自动中的键和值分别不能大于等于 keys values 集合元素的数量。 例如, 一个 GeoJSON 特征: 可以被构造为这样： 记住，几何形状的精确值会根据贴图的投影和范围而不同。

#include <iostream>#include <algorithm>#include <functional>#include <vector>using namespace std;class myclass { public: myclass(int a, int b):first(a), second(b){} int first; int second; bool operator < (const myclass &m)const { return first < m.first; }};bool less_second(const myclass & m1, const myclass & m2) { return m1.second < m2.second;}int main() { vector< myclass > vect; for(int i = 0 ; i < 10 ; i ++){ myclass my(10-i, i*3); vect.push_back(my); } for(int i = 0 ; i < vect.size(); i ++) cout<<"("<<vect[i].first<<","<<vect[i].second<<") "; sort(vect.begin(), vect.end()); cout<<"after sorted by first:"<<endl; for(int i = 0 ; i < vect.size(); i ++) cout<<"("<<vect[i].first<<","<<vect[i].second<<") "; cout<<"after sorted by second:"<<endl; sort(vect.begin(), vect.end(), less_second); for(int i = 0 ; i < vect.size(); i ++) cout<<"("<<vect[i].first<<","<<vect[i].second<<") "; return 0 ;}

#include <iostream>#include<algorithm>#include <vector>int main(){ using namespace std ; int intList1[] = {1,2,3,4}; //int intList2[] = {1,2,3,4}; int intList2[] = { 5,6,3,4 } ; vector<int>vecList1(intList1,intList1+4); // +4 不是 +5 vector<int>vecList2(intList2,intList2+4); vector<int>::iterator vecIterator1 = vecList1.begin(); vector<int>::iterator vecIterator2 = vecList2.begin() ; while( vecIterator2 !=vecList2.end()) { if(*vecIterator1++ == *vecIterator2++) {//earse()会让vecIterator1会失效,你得重新让它接受个合格的. vecIterator1 = vecList1.erase(--vecIterator1); continue ; } } if(vecList1.empty()) cout<<"It is the same ."<<endl; else { //copy中的ostream_itearator<>可能无法在VC6.0下编译,你可以换成你的输出code. cout <<"Different elements are as follows: " << endl ; copy( vecList1.begin(), vecList1.end(), ostream_iterator<int>( cout, " " ) ) ; cout << endl ; }}

ocos2d-x vector能使用结构体吗 vector可以存放自定义的结构体，方法有：放入这个结构体类

这样写就好了#include<iostream>#include<vector>using namespace std;int main(){ vector<float> v1; vector<float> v2; vector<float> v3; float a,b; for(int i=0;i<2;i++){ cin>>a; v1.push_back(a);} for(int i=0;i<v1.size();i++) cout<<v1[i]<<","; cout<<endl; for(int i=0;i<2;i++) { cin>>b; v2.push_back(b); } for(int i=0;i<v2.size();i++) cout<<v2[i]<<","; cout<<endl; for(int ix=0;ix!=v1.size();ix++) v3.push_back(v1[ix]+v2[ix]); for(int i=0;i<2;i++) cout<<v3[i]<<","; cout<<endl; return 0;}

vector英 ["vektu0259]美 ["vu025bktu025a]n. 矢量；带菌者；航线vt. 用无线电导航

vector<vector<int> >这样扩展行吧？没试过，不知道行不行 #include<iostream>#include<vector>using namespace std;int main(){ vector<int>vec; vector<vector<int> >v_vec; int x; for(int j=0;j<3;j++) { for(int i=0;i<4;i++) { cin>>x;vec.push_back (x); } v_vec.push_back (vec); vec.clear (); } cout<<v_vec.size ()<<endl; return 0;}貌似可以，但是我不知道怎么访问。

Victor可以

如下就实现了降序算法：bool Comp(const int &a, const int &b){ return a > b ;}void main(){ vector v ; for (i = 0 ; i < 10 ; i++) { v.push_back(i) ; } sort(v.begin(), v.end(), Comp) ;}

#include<vector>using namespace std;

跟数组一样……

实现向量容器的类名是vector（容器是类模板）。包含vector类的头文件名是vector。所以，如果要在程序里使用向量容器，就要在程序中包含下面语句：#include <vector>此外，在定义向量类型对象时，必须指定该对象的类型，因为vector类是一个类模板。例如，语句：vector<int> intList; 将intList声明为一个元素类型为int的向量容器对象。类似地，语句：vector<string> stringList;将stringList声明为一个元素类型为string的向量容器对象。声明向量对象vector类包含了多个构造函数，其中包括默认构造函数。因此，可以通过多种方式来声明和初始化向量容器。

std::vector<int> v1, v2 ;v1.insert(v1.end(), v2.begin(), v2.end());

list的实现是链表，vector的底层实现是数组

#include<iostream>#include<vector>using namespace std;int main(){ vector<int> v2(10);//对象中有10个元素 vector<int>::size_type ix=0; // v2.push_back(10);//注释掉的这句用来检测添加新元素的时候的容量和元素个数的关系 cout<<v2.capacity()<<endl;//输出容器的容量。 cout<<v2.size()<<endl;//输出容器中的元素个数 while(ix!=v2.size()){ cout<<v2[ix++]<<" "; }//通过下标输出容器中的元素 cout<<endl; for(vector<int>::iterator iter=v2.begin();iter!=v2.end();++iter){ cout<<*iter<<" "; }//通过迭代器输出容器中的元素 cout<<endl; system("pause"); return 0;}/*因为vector的元素是连续存储的，当给容器中添加元素时，如果没有可以容纳新元素的空间，那么vector必须重新分配存储空间，用来存放原来的元素以及新添加的元素，最后撤销旧的存储空间，如果vector每次添加元素都分配和撤销内存，效率会很低。capacity操作获取在容器需要分配更多的内存空间之前能够存储的元素总数。*/

vector c++用法就是必须在头文件中包含#include代码。vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象。简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。Vector是一个开源主机性能监控框架，能高分辨采集系统和应用程序的各种数据输出到浏览器中，相比传统通过登录主机运行各种命令获得系统度量情况，使用Vector能更快地响应系统运维情况。可以运行在任何HTTP服务可用之上，比如Apache或Nginx。c语言特点C语言是一种结构化语言，它有着清晰的层次，可按照模块的方式对程序进行编写，十分有利于程序的调试，且c语言的处理和表现能力都非常的强大，依靠非常全面的运算符和多样的数据类型，可以轻易完成各种数据结构的构建，通过指针类型更可对内存直接寻址以及对硬件进行直接操作，因此既能够用于开发系统程序，也可用于开发应用软件。C语言是一种结构化的语言，提供的控制语句具有结构化特征，例如for语句、if...else语句和switch语句等。可以用于实现函数的逻辑控制，方便面向过程的程序设计。包含的数据类型广泛，不仅包含传统的字符型、整型、浮点型、数组类型等数据类型，还具有其他编程语言所不具备的数据类型。

绝对可以

vector冲锋枪读作“维克托”冲锋枪。克里斯矢量冲锋枪是美国克里斯公司开发和制造的冲锋枪。它也被称为短剑冲锋枪和火力ACP手枪子弹。kris成立时名为转型国防工业（TDI）。该火炮采用不均匀后座力和同轴设计，以解决严重的后座力和炮口升力.45口径。设计细节：虽然kris矢量系列的原型是由瑞士设计的，但其专利枪技术最初是由法国工程师RenaudKerbrat设计的，并命名为KSV系统。它是一种铰接式机械延迟后坐炮，在炮后有一个平衡质量来传递后坐力和延迟后坐力。当子弹发射炮弹在高压火药气体反冲击退主体的作用下螺栓，螺栓锁必须首先克服体重平衡块后延迟锁定斜率，然后开始反向运动水平，并通过平衡重块，一斜面力平衡重块在复合块的引导下成弹簧导向杆向下运动，再送料弹簧被压入导槽内，导槽后方可容纳火炮。此时，由于炮耳卡在平衡块的导向槽内，当火炮水平移动一段距离时，在平衡块的带动下离开中心轴，向下偏转。再入弹簧完全压缩后，再入就开始了。再入弹簧开始反弹平衡重量块并向上移动。在同一斜面的作用下，机枪向上向前移动。返回中轴后，弹匣内的下一颗子弹被推动装填并向前移动，直到枪机端面与枪管腔端部对齐，关闭枪管腔端部形成锁定。Vector系列不是第一个用这种机器操作的枪。

std_logic_vector 是标准逻辑矢量,定义的是长度大于1的变量，需要确定赋值方向 （n downto 0） or （0 downto n）。std_logic 是长度为1的逻辑 与bit 相似，只是 bit 只能是"0 "和"1‘ 而 std_logic有以下九种状态：U"——初始值，"X"——不定，"0"——0，"1"——1，"Z"——高阻，"W"——弱信号不定，"L"——弱信号0，"H"——弱信号1，"-"——不可能的情况

1、v.push_back(k); 尾插元素；2、v.insert(it,k); 在任意位置插入元素；3、v.eraser(it,it+k); 删除任意元素；4、v.size(); 容量；5、v.clear(); 清空容器；6、v.empty(); 判断容器是否为空；7、reverse(v.begin(),v.end());反转任意段元素8、sort(v.begin(),v.end()，cmp);sort排序默认由小到大,cmp可以自由规定排序规则。

D3DXMATRIX* WINAPI D3DXMatrixInit(D3DXMATRIX* pOut,float m11, float m12, float m13, float m14,float m21, float m22, float m23, float m24,float m31, float m32, float m33, float m34,float m41, float m42, float m43, float m44){ pOut->_11 = m11; pOut->_12 = m12; pOut->_13 = m13; pOut->_14 = m14; pOut->_21 = m21; pOut->_22 = m22; pOut->_23 = m23; pOut->_24 = m24; pOut->_31 = m31; pOut->_32 = m32; pOut->_33 = m33; pOut->_34 = m34; pOut->_41 = m41; pOut->_42 = m42; pOut->_43 = m43; pOut->_44 = m44; return pOut;}D3DXMATRIX* WINAPI D3DXMatrixMultiply ( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 ){ ATLASSERT(pOut!=NULL&&pM1!=NULL&&pM2!=NULL); D3DXMATRIX matTemp; float fSum = 0; for (int nRow=0; nRow<4; nRow++) { for (int nCol=0; nCol<4; nCol++) { fSum=0; for (int nIndex=0;nIndex<4; nIndex++) { fSum+=pM1->m[nRow][nIndex]*pM2->m[nIndex][nCol]; } matTemp.m[nRow][nCol] = fSum; } } pOut[0]=matTemp; return pOut;}D3DXMATRIX* WINAPI D3DXMatrixScaling ( D3DXMATRIX *pOut, FLOAT sx, FLOAT sy, FLOAT sz ){ D3DXMatrixIdentity(pOut); pOut->_11=sx; pOut->_22=sy; pOut->_33=sz; return pOut;}D3DXMATRIX* WINAPI D3DXMatrixTranslation ( D3DXMATRIX *pOut, FLOAT x, FLOAT y, FLOAT z ){ D3DXMatrixIdentity(pOut); pOut->_41=x; pOut->_42=y; pOut->_43=z; return pOut;}D3DXMATRIX* WINAPI D3DXMatrixRotationX ( D3DXMATRIX *pOut, FLOAT Angle ){ FLOAT fCos=cos(Angle); FLOAT fSin=sin(Angle); D3DXMatrixInit(pOut,1,0,0,0, 0,fCos,fSin,0, 0,-fSin,fCos,0, 0,0,0,1); return pOut;}D3DXMATRIX* WINAPI D3DXMatrixRotationY ( D3DXMATRIX *pOut, FLOAT Angle ){ FLOAT fCos=cos(Angle); FLOAT fSin=sin(Angle); D3DXMatrixInit(pOut, fCos,0,-fSin,0, 0,1,0,0, fSin,0,fCos,0, 0,0,0,1); return pOut;}D3DXMATRIX* WINAPI D3DXMatrixRotationZ ( D3DXMATRIX *pOut, FLOAT Angle ){ FLOAT fCos=cos(Angle); FLOAT fSin=sin(Angle); D3DXMatrixInit(pOut, fCos,0,fSin,0, -fSin,fCos,0,0, 0,0,1,0, 0,0,0,1); return pOut;}D3DXMATRIX* WINAPI D3DXMatrixRotationYawPitchRoll ( D3DXMATRIX *pOut, FLOAT Yaw, FLOAT Pitch, FLOAT Roll ){ D3DXMATRIX matTemp; D3DXMatrixRotationY(pOut,Yaw); D3DXMatrixRotationX(&matTemp,Pitch); D3DXMatrixMultiply(pOut,pOut,&matTemp); D3DXMatrixRotationZ(&matTemp,Roll); D3DXMatrixMultiply(pOut,pOut,&matTemp); return pOut;}D3DXVECTOR4* WINAPI D3DXVec4Transform ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, CONST D3DXMATRIX *pM ){ FLOAT fSum = 0; ATLASSERT(pOut!=pV); for (int nCol=0; nCol < 4; nCol++) { fSum=0; for (int nRow=0; nRow<4; nRow++) { fSum+=((FLOAT*)pV)[nRow]*pM->m[nRow][nCol]; } ((FLOAT*)pOut)[nCol] = fSum; } return pOut;}D3DXVECTOR4* WINAPI D3DXVec4TransformArray ( D3DXVECTOR4 *pOut, UINT OutStride, CONST D3DXVECTOR4 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n ){ ATLASSERT(pOut!=pV); return pOut;}注意：不要用中文状态下的标点符号，否则会有很多错误。

向量具体就是数组的升级，用在需要容器的程序中，但比数组好用的多。literator是遍历器，用来遍历每个元素。如输出向量中的所有元素，有2种方式：//a为向量for(inti=0;i::iteratorit=a.begin();it!=a.end();++it)cout<<*it<

vector适用：对象数量变化少，简单对象，随机访问元素频繁list适用：对象数量变化大，对象复杂，插入和删除频繁最大的区别是,list是双向的，而vector是单向的。list和vector的区别会分开的说明1、vector为存储的对象分配一块连续的地址空间，因此对vector中的元素随机访问效率很高。2、在vecotor中插入或者删除某个元素，需要将现有元素进行复制，移动。如果vector中存储的对象很大，或者构造函数复杂，则在对现有元素进行拷贝时开销较大，因为拷贝对象要调用拷贝构造函数。3、对于简单的小对象，vector的效率优于list。vector在每次扩张容量的时候，将容量扩展2倍，这样对于小对象来说，效率是很高的。4、list中的对象是离散存储的，随机访问某个元素需要遍历list。在list中插入元素，尤其是在首尾插入元素，效率很高，只需要改变元素的指针。

v.erase(0,1);

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

#include "Vector.h"

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

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

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

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

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

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

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

#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;}

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

vehicle和vector的区别：意思不同：vehicle意为“车辆、工具、交通工具、运载工具、传播媒介、媒介物。”，而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;}

定义一个整形vector引用变量

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

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看看里面有更详细的内容 而且比较基础

#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;}

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

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的值补全。

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

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

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

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看看里面有更详细的内容 而且比较基础

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

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<vector<int> > matrix(row,vector<int>(col,0));这个代码的含义是：vector<vector<int> >外层的vector就是那个用于存储vector的，是第二维，它包含row个一维的vector，而每一个一维的vector包含col个int。后面的matrix里面是调用了vector的构造函数进行这个结构的构造。

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

一个可变大小的集合之类的吧，看JDK里的英文说明是这个意思

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

定义了一个vector二维向量，其中每个元素都是vector<int>,意思就是，定义了n个int类型的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是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()范围的数据。

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

就是“向量”

Maybe "容器"

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

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

在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<int> data;vector<double> data_d(data.begin(), data.end());