vector c++ 用法,c++ 用vector 定义二维数组
vector c++ 用法,c++ 用vector 定义二维数组详细介绍
本文目录一览： C++ vector用法是什么？
vector容器类型
vector容器是一个模板类，可以存放任何类型的对象（但必须是同一类对象）。vector对象可以在运行时高效地添加元素，并且vector中元素是连续存储的。
vector的构造
函数原型：
template
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
v1; // 创建空容器，其对象类型为string类
vector
v2(10); // 创建有10个具有初始值（即空串）的string类对象的容器
vector
v3(5, "hello"); // 创建有5个值为“hello”的string类对象的容器
vector
v4(v3.begin(), v3.end()); // v4是与v3相同的容器（完全复制）
vector的操作（下面的函数都是成员函数）
bool empty() const; // 如果为容器为空，返回true；否则返回false
size_type max_size() const; // 返回容器能容纳的最大元素个数
size_type size() const; // 返回容器中元素个数
size_type capacity() const; // 容器能够存储的元素个数，有：capacity() >= size()
void reserve(size_type n); // 确保capacity() >= n
void 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_range
const_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
#include
#include
using namespace std;
int main()
{
vector
v(5, "hello");
vector
v2(v.begin(), v.end());
assert(v == v2);
cout<<"> Before operation"<
<endl;
for(vector
::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
::size_type i = 0; i < v.size(); ++i)
cout<
<v[i]<<endl;
vector
::iterator it = v.erase(v.begin() + 3, v.begin() + 6);
assert(*it == "hello, world");
cout<<"> After erase"<
<endl;
for(vector
::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
::difference_type(v.size()));
return 0;
}
程序说明：上面程序中用了三个循环输出容器中的元素，每个循环的遍历方式是不一样的。特别需要说明的是，第二个循环在条件判断中使用了size() 函数，而不是在循环之前先保存在变量中再使用。之所以这样做，有两个原因：其一，如果将来在修改程序时，在循环中修改了容器元素个数，这个循环仍然能很好 地工作，而如果先保存size()函数值就不正确了；其二，由于这些小函数（其实现只需要一条返回语句）基本上都被声明为inline，所以不需要考虑效率问题。
在网上找的 还有很多 建议你还是买一本stl看看里面有更详细的内容 而且比较基础
</v[i]<<endl;
</endl;
</v[i]<<endl;
</endl;
</endl;
</endl;
</n，那么用元素x的值补全。
vector(vector(float) )的使用方法
给你一个例子，没有注释的，但运行后你就应该知道怎么用了：
#include
#include
using namespace std;
void main()
{
vector
vf0;
vf0.push_back( 1.0 );
vf0.push_back( 1.1 );
vector
vf1;
vf1.push_back( 2.0 );
vf1.push_back( 2.1 );
vector
<vector
> vff;
vff.push_back(vf0);
vff.push_back(vf1);
for ( int i = 0; i < vff.size(); i++)
{
for ( int j = 0; j < vff[i].size(); j++)
{
cout << "vff[" << i << "][" << j << "] = " << vff[i][j] << endl;
}
}
}
下面是我给你写的一个例子
在Linux下面g++编译 运行结果是这样的:
root@ubuntu:~/workspaces/temp# g++ -o cplus cplus.cc
root@ubuntu:~/workspaces/temp# ./cplus
10
11
结果通过
注意 vector< vector
> 第一个<>中的vector
前后
要有空格
//##############################################
#include
#include
using namespace std;
int main(void)
{
vector< vector
> vfs;
vector
vs ;
vs.push_back(10.0);
vs.push_back(11.0);
cout<
<vs[0]<<endl;
vfs.push_back(vs);
vector
vs_ref = vfs[0];
cout<
<vs_ref[1]<<endl;
return 0;
}
给你一个例子，没有注释的，但运行后你就应该知道怎么用了：
#include
#include
using
namespace
std;
void
main()
{
vector
vf0;
vf0.push_back(
1.0
);
vf0.push_back(
1.1
);
vector
vf1;
vf1.push_back(
2.0
);
vf1.push_back(
2.1
);
vector
>
vff;
vff.push_back(vf0);
vff.push_back(vf1);
for
(
int
i
=
0;
i
<
vff.size();
i++)
{
for
(
int
j
=
0;
j
<
vff[i].size();
j++)
{
cout
<<
"vff["
<<
i
<<
"]["
<<
j
<<
"]
=
"
<<
vff[i][j]
<<
endl;
}
}
}
取vector
a的第3个元素：auto
p
=
a[2];
//得到一个pair
取pair的第二个元素：int
i
=
p.second;
结合一下：int
i
=
a[2].second;
在c++中，vector是一个十分有用的容器。作用：它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。
使用vector需要注意以下几点：
1、如果你要表示的向量长度较长（需要为向量内部保存很多数），容易导致内存泄漏，而且效率会很低；
2、Vector作为函数的参数或者返回值时，需要注意它的写法：double Distance(vector
&a, vector
&b) 其中的“&”绝对不能少。
扩展资料
vector的基本操作：
(1)头文件#include
(2)创建vector对象，vector
vec；
(3)尾部插入数字：vec.push_back(a)；
(4)使用下标访问元素，cout<
<vec[0]<<endl;记住下标是从0开始的。
(5)使用迭代器访问元素
vector
::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开始。
</endl;
</vec[0]<<endl;记住下标是从0开始的。
</vs_ref[1]<<endl;
</vs[0]<<endl;
</vector
c++里vector怎么用？
vector
变量名 //声明
vector
vi = ( 10 , 1 ) //初始化为10个元素的vector，每个元素都为1
这里有个汇总，非常详细：
http://anony3721.blog.163.com/blog/static/511380031017780/
vector、map、list、queue等都是c++的模板。vector相当于c中数组，长度是变化的。vector
test（100）；这里定义了一个vector，test，预定义的大小是100。操作vector里面的数最好用迭代器：Iterator。
#include
就行，
vector
myvector;
myvector.push_back(10); myvector.push_back(30); myvector.push_back(20);
遍历：
vector
::iterator p1;
for(p1=myvector.begin();p1!=myvector.end();p1++)
http://blog.sina.com.cn/s/blog_60792c900100f3l8.html
(1)vector< 类型 > 标识符 ;
(2)vector< 类型 > 标识符(最大容量) ；
(3)vector< 类型 > 标识符（最大容量，初始所有值）；
(4) int i[4] = {12,3,4,5};
vector< 类型 > vi(i , i+2); //得到i索引值为3以后的值 ；
(5)vector< vector
> //vi 定义2维的容器；记得一定要有空格，不然会报错
vector< int > line
// 在使用的时候一定要首先将vi个行进行初始化;
for(int i = 0 ; i < 10 ; i ++)
{
vector.push_back(line);
}
/// 个人认为使用vector定义二维数组很好，
因为是长度可以不预先确定。很好。
(6)C++ Vector排序
vector< int > vi ; vi.push_back(1); vi.push_back(3); vi.push_back(0); sort(vi.begin() , vi.end()); /// /小到大 reverse(vi.begin(),vi.end()) /// 从大道小
(7)顺序访问
vector < int > vi ; for( int i = 0 ; i < 10 ; i ++) { vector.push_back(i); } for(int i = 0 ; i < 10 ; i ++) /// 第一种调用方法 { cout <
<vector[i] <<" " ; } for(vector
::iterator it = vi.begin() ; it !=vi.end() ; it++) ///第二种调用方法 { cout << *it << " " ; }
(8)寻找
vector < int > vi ; for( int i = 0 ; i < 10 ; i ++) { vector.push_back(i); } vector < int >::interator it = find(vi.begin() , vi.end,3) ; cout << *it << endl ; ///返回容器内找到值的位置。
(9)使用数组对C++ Vector进行初始化
int i[10] ={1,2,3,4,5,6,7,78,8} ; ///第一种 vector
vi(i+1,i+3); ///从第2个元素到第三个元素 for(vector
::interator it = vi.begin() ; it != vi.end() ; it++) { cout << *it <<" " ; }
(10) 结构体类型
struct temp { public : string str ; public : int id ; }tmp int main() { vector
t ; temp w1 ; w1.str = "Hellowor" ; w1.id = 1 ; t.push_back(t1); cout << w1.str << "," <
<w1.id <<endl ; return 0 }
vector类为内置数组提供了一种替代表示，与string类一样 vector 类是随标准
C++引入的标准库的一部分 ，为了使用vector 必须包含相关的头文件 。
vector使用大全， 资料！！！c++
vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。
为了可以使用vector，必须在你的头文件中包含下面的代码：
#include
vector属于std命名域的，因此需要通过命名限定，如下完成你的代码：
using
std::vector;
vector
vInts;
或者连在一起，使用全名：
std::vector
vInts;
建议使用全局的命名域方式：using
namespace
std;
函数
表述
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
cvector
c1(c2)
vector
c(n)
ector
c(n,
elem)
vector
c(beg,end)
c.~
vector
()
创建一个空的vector。复制一个vector。创建一个vector，含有n个数据，数据均已缺省构造产生。创建一个含有n个elem拷贝的vector。创建一个以[beg;end)区间的vector。销毁所有数据，释放内存。
operator[]
返回容器中指定位置的一个引用。
创建一个vector
vector容器提供了多种创建方法，下面介绍几种常用的。
创建一个Widget类型的空的vector对象：
vector
vWidgets;
创建一个包含500个Widget类型数据的vector：
vector
vWidgets(500);
创建一个包含500个Widget类型数据的vector，并且都初始化为0：
vector
vWidgets(500,
Widget(0));
创建一个Widget的拷贝：
vector
vWidgetsFromAnother(vWidgets);
向vector添加一个数据
vector添加数据的缺省方法是push_back()。push_back()函数表示将数据添加到vector的尾部，并按需要来分配内存。例如：向vector
中添加10个数据，需要如下编写代码：
for(int
i=
0;i<10;
i++)
{
vWidgets.push_back(Widget(i));
}
获取vector中制定位置的数据
vector里面的数据是动态分配的，使用push_back()的一系列分配空间常常决定于文件或一些数据源。如果想知道vector存放了多少数据，可以使用empty()。获取vector的大小，可以使用size()。例如，如果想获取一个vector
v的大小，但不知道它是否为空，或者已经包含了数据，如果为空想设置为-1，你可以使用下面的代码实现：
int
nSize
=
v.empty()
?
-1
:
static_cast
(v.size());
访问vector中的数据
使用两种方法来访问vector。
1、
vector::at()
2、
vector::operator[]
operator[]主要是为了与C语言进行兼容。它可以像C语言数组一样操作。但at()是我们的首选，因为at()进行了边界检查，如果访问超过了vector的范围，将抛出一个例外。由于operator[]容易造成一些错误，所有我们很少用它，下面进行验证一下：
分析下面的代码：
vector
v;
v.reserve(10);
for(int
i=0;
i<7;
i++)
{
v.push_back(i);
}
try
{int
iVal1
=
v[7];
//
not
bounds
checked
-
will
not
throw
int
iVal2
=
v.at(7);
//
bounds
checked
-
will
throw
if
out
of
range
}
catch(const
exception&
e)
{
cout
<<
e.what();
}
删除vector中的数据
vector能够非常容易地添加数据，也能很方便地取出数据，同样vector提供了erase()，pop_back()，clear()来删除数据，当删除数据时，应该知道要删除尾部的数据，或者是删除所有数据，还是个别的数据。
Remove_if()算法
如果要使用remove_if()，需要在头文件中包含如下代码：：
#include
Remove_if()有三个参数：
1、
iterator
_First：指向第一个数据的迭代指针。
2、
iterator
_Last：指向最后一个数据的迭代指针。
3、
predicate
_Pred：一个可以对迭代操作的条件函数。
条件函数
条件函数是一个按照用户定义的条件返回是或否的结果，是最基本的函数指针，或是一个函数对象。这个函数对象需要支持所有的函数调用操作，重载operator()()操作。remove_if()是通过unary_function继承下来的，允许传递数据作为条件。
例如，假如想从一个vector
中删除匹配的数据，如果字串中包含了一个值，从这个值开始，从这个值结束。首先应该建立一个数据结构来包含这些数据，类似代码如下：
#include
enum
findmodes
{
FM_INVALID
=
0,
FM_IS,
FM_STARTSWITH,
FM_ENDSWITH,
FM_CONTAINS
};
typedef
struct
tagFindStr
{
UINT
iMode;
CString
szMatchStr;
}
FindStr;
typedef
FindStr*
LPFINDSTR;
然后处理条件判断：
class
FindMatchingString
:
public
std::unary_function
<cstring,
bool>
{
public:
FindMatchingString(const
LPFINDSTR
lpFS)
:
m_lpFS(lpFS)
{
}
bool
operator()(CString&
szStringToCompare)
const
{
bool
retVal
=
false;
switch
(m_lpFS->iMode)
{
case
FM_IS:
{
retVal
=
(szStringToCompare
==
m_lpFDD->szMatchStr);
break;
}
case
FM_STARTSWITH:
{
retVal
=
(szStringToCompare.Left(m_lpFDD->szMatchStr.GetLength())
==
m_lpFDD->szWindowTitle);
break;
}
case
FM_ENDSWITH:
{
retVal
=
(szStringToCompare.Right(m_lpFDD->szMatchStr.GetLength())
==
m_lpFDD->szMatchStr);
break;
}
case
FM_CONTAINS:
{
retVal
=
(szStringToCompare.Find(m_lpFDD->szMatchStr)
!=
-1);
break;
}
}
return
retVal;
}
private:
LPFINDSTR
m_lpFS;
};
通过这个操作你可以从vector中有效地删除数据：
FindStr
fs;
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是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。
为了可以使用vector，必须在你的头文件中包含下面的代码：
#include
vector属于std命名域的，因此需要通过命名限定，如下完成你的代码：
using std::vector;
vector
vInts;
或者连在一起，使用全名：
std::vector
vInts;
建议使用全局的命名域方式：using namespace std;
函数
表述
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)
在尾部加入一个数据。
vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。
为了可以使用vector，必须在你的头文件中包含下面的代码：
#include
vector属于std命名域的，因此需要通过命名限定，如下完成你的代码：
using std::vector;
vector
vInts;
或者连在一起，使用全名：
std::vector
vInts;
建议使用全局的命名域方式：using namespace std;
函数
表述
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
cvector
c1(c2)
vector
c(n)
ector
c(n, elem)
vector
c(beg,end)
c.~ vector
()
创建一个空的vector。复制一个vector。创建一个vector，含有n个数据，数据均已缺省构造产生。创建一个含有n个elem拷贝的vector。创建一个以[beg;end)区间的vector。销毁所有数据，释放内存。
operator[]
返回容器中指定位置的一个引用。
创建一个vector
vector容器提供了多种创建方法，下面介绍几种常用的。
创建一个Widget类型的空的vector对象：
vector
vWidgets;
创建一个包含500个Widget类型数据的vector：
vector
vWidgets(500);
创建一个包含500个Widget类型数据的vector，并且都初始化为0：
vector
vWidgets(500, Widget(0));
创建一个Widget的拷贝：
vector
vWidgetsFromAnother(vWidgets);
向vector添加一个数据
vector添加数据的缺省方法是push_back()。push_back()函数表示将数据添加到vector的尾部，并按需要来分配内存。例如：向vector
中添加10个数据，需要如下编写代码：
for(int i= 0;i<10; i++) {
vWidgets.push_back(Widget(i));
}
获取vector中制定位置的数据
vector里面的数据是动态分配的，使用push_back()的一系列分配空间常常决定于文件或一些数据源。如果想知道vector存放了多少数据，可以使用empty()。获取vector的大小，可以使用size()。例如，如果想获取一个vector v的大小，但不知道它是否为空，或者已经包含了数据，如果为空想设置为-1，你可以使用下面的代码实现：
int nSize = v.empty() ? -1 : static_cast
(v.size());
访问vector中的数据
使用两种方法来访问vector。
1、 vector::at()
2、 vector::operator[]
operator[]主要是为了与C语言进行兼容。它可以像C语言数组一样操作。但at()是我们的首选，因为at()进行了边界检查，如果访问超过了vector的范围，将抛出一个例外。由于operator[]容易造成一些错误，所有我们很少用它，下面进行验证一下：
分析下面的代码：
vector
v;
v.reserve(10);
for(int i=0; i<7; i++) {
v.push_back(i);
}
try {int iVal1 = v[7];
// not bounds checked - will not throw
int iVal2 = v.at(7);
// bounds checked - will throw if out of range
} catch(const exception& e) {
cout << e.what();
}
删除vector中的数据
vector能够非常容易地添加数据，也能很方便地取出数据，同样vector提供了erase()，pop_back()，clear()来删除数据，当删除数据时，应该知道要删除尾部的数据，或者是删除所有数据，还是个别的数据。
Remove_if()算法 如果要使用remove_if()，需要在头文件中包含如下代码：：
#include
Remove_if()有三个参数：
1、 iterator _First：指向第一个数据的迭代指针。
2、 iterator _Last：指向最后一个数据的迭代指针。
3、 predicate _Pred：一个可以对迭代操作的条件函数。
条件函数
条件函数是一个按照用户定义的条件返回是或否的结果，是最基本的函数指针，或是一个函数对象。这个函数对象需要支持所有的函数调用操作，重载operator()()操作。remove_if()是通过unary_function继承下来的，允许传递数据作为条件。
例如，假如想从一个vector
中删除匹配的数据，如果字串中包含了一个值，从这个值开始，从这个值结束。首先应该建立一个数据结构来包含这些数据，类似代码如下：
#include
enum findmodes {
FM_INVALID = 0,
FM_IS,
FM_STARTSWITH,
FM_ENDSWITH,
FM_CONTAINS
};
typedef struct tagFindStr {
UINT iMode;
CString szMatchStr;
} FindStr;
typedef FindStr* LPFINDSTR;
然后处理条件判断：
class FindMatchingString : public std::unary_function
{
public:
FindMatchingString(const LPFINDSTR lpFS) :
m_lpFS(lpFS) {
}
bool operator()(CString& szStringToCompare) const {
bool retVal = false;
switch (m_lpFS->iMode) {
case FM_IS: {
retVal = (szStringToCompare == m_lpFDD->szMatchStr);
break;
}
case FM_STARTSWITH: {
retVal = (szStringToCompare.Left(m_lpFDD->szMatchStr.GetLength())
== m_lpFDD->szWindowTitle);
break;
}
case FM_ENDSWITH: {
retVal = (szStringToCompare.Right(m_lpFDD->szMatchStr.GetLength())
== m_lpFDD->szMatchStr);
break;
}
case FM_CONTAINS: {
retVal = (szStringToCompare.Find(m_lpFDD->szMatchStr) != -1);
break;
}
}
return retVal;
}
private:
LPFINDSTR m_lpFS;
};
通过这个操作你可以从vector中有效地删除数据：
FindStr fs;
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()范围的数据。
</cstring,
c++中vector的作用是什么？
一个动态数组模板类，你可以把它当做一个普通数组用，但是他的功能远比一般数组强大，数组最大的不好就是数组长度的限制和删除其中一个时候的后续移位问题，这些在vector中都得到了完美的解决，而且可以存储结构体什么的，用起来也像普通数组那样简单，直接加【】就可以取值。
相当于动态数组。
比如 char str[100];
只能存储100个字符。
vector可以动态增长。
vector
str(10,'A'); //初始化为包含10个'A'字符的数组
str.push_back('B'); // 现在str有11个字符
str.push_back('C'); // 现在str有12个字符
printf("%c",str[0]); //输出A
printf("%c",str[9]); //输出A
printf("%c",str[10]); //输出B
printf("%c",str[11]); //输出C
形象点说就是封装成类一个顺序表
c++中，vector作为容器，它的作用是：用来存放结构体struct类型的变量。以下是vector的具体用法：
工具/材料：电脑、c++编译器
1、首先，打开c++编译器，构造一个int类型的空vector向量。
2、程序运行结果如图，可以看到vector的size为0。
3、如红框勾选所示，构造了6个元素值为20的vector向量。
4、运行结果显示，成功的构造了6个元素为20的向量。
5、以现有vector对象的范围作为构造函数的参数，同样也将对象复制给另一个vector对象。
6、以下，就是程序运行结果了。
c++, 我不太明白vector都是什么时候用呢？
vector 是个容器，它定义了很多的方法，它帮你管理动态内存。
如果可以用vector就尽量用，vector是所有容器里面效率最高的，它的内部实现就是数组。
vector帮你做了动态内存分配，你不用费心处理指针的问题，避免了new跟delete操作。
总结下，就是尽量用容器vector，不要自己费心用new来管理指针。
vector
vec;
这样就建立了一个空容器，不需要new的，至于它内部的方法和构造函数，可以查阅相关基础书籍。
vector是C++提供的容器的一种, 也就是存储数据, 这只是其中的一种
vector在原本使用数组的地方均可以替代, 并且其可以动态增长,不需要考虑大小.
另外还有其他几种类型的容器, vector的优点是随机存取,也就是可以使用下标访问.
vector和数组是一样的东西，如果你去看源码，你会发现vector里面最终的存储也是数组，只是vector将数组做了类的封装，这样原来C语言中的数组的一些问题，如越界、数组大小这些都可以在vector中得到比较好的处理，基本上来说，在C++中能用到数组的地方，都可以用vector来代替，但是有一些地方数组是不能被vector代替的，也就是内存容量较小的地方，你使用过vector就知道，你声明了一个vector变量后，直接用push_back就可以往里面存储东西，而不用去特意的申请内存，这是由于vector内部的一些机制造成的，比较复杂，有兴趣可以去细看，这里我简单说一下：当你往vector内存储数据时，如果这时vector容量已经满了那么vector会申请比当前容量大两倍的内存，然后将现有的数据拷贝到新申请的内存中，比较耗资源的。
至于你说要不要用new，这个就看你个人具体应用了，new是在内存的堆中申请存储空间的，如果不用new是在栈区申请空间，关于堆栈区，你可以去查查资料看看。new这个东西就像上面说的，是用来向操作系统申请空间的一个说明，对于vector即便你不申请内存，往里面用push_back添加数据的话，它也会自动的向内存申请空间的。
希望帮到你。
------
sort是来自
这个算法头文件的，具体用法参考这里：
http://www.cplusplus.com/reference/algorithm/sort/
sort大体用法就是对一个容器应用一个你自定义的大小比较函数来对提供的范围内的元素排序。
find同样是来自
文件，用法和sort差不多：
http://www.cplusplus.com/reference/algorithm/find/
你看下对应的例子就应该能明白了。
你要找v中的30000的话，用find：
find(vec.begin() , vec.end() , 30000) != vec.end() ; //这个表示找到，否则就是没有找到了，具体可以看发给你的链接里面的详细说明和例子
祝好运。
vector(string)怎么用
容器向量也是一个类模板。标准库vector类型使用须要的头文件：#include
。vector 是一个类模板。不是一种数据类型，vector
是一种数据类型。Vector的存储空间是连续的,list不是连续存储的。
定义和初始化
vector< typeName > v1; //默认v1为空，故以下的赋值是错误的v1[0]=5;
vector
v2(v1); 或v2=v1;或vector
v2(v1.begin(), v1.end());//v2是v1的一个副本，若v1.size（）>v2.size()则赋值后v2.size()被扩充为v1.size()。
vector< typeName > v3(n,i);//v3包括n个值为i的typeName类型元素
vector< typeName > v4(n); //v4含有n个值为0的元素
int a[4]={0,1,2,3,3}; vector
v5(a,a+5);//v5的size为5，v5被初始化为a的5个值。后一个指针要指向将被拷贝的末元素的下一位置。
vector
v6(v5);//v6是v5的拷贝
vector< 类型 > 标识符（最大容量，初始全部值）；
扩展资料向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。
特征
1、顺序序列
顺序容器中的元素按照严格的线性顺序排序。可以通过元素在序列中的位置访问对应的元素。
2、动态数组
支持对序列中的任意元素进行快速直接访问，甚至可以通过指针算述进行该操作。操供了在序列末尾相对快速地添加/删除元素的操作。
3、能够感知内存分配器的（Allocator-aware）
容器使用一个内存分配器对象来动态地处理它的存储需求。
参考资料来源：百度百科—向量
容器向量也是一个类模板。标准库vector类型使用须要的头文件：#include
。vector 是一个类模板。不是一种数据类型，vector
是一种数据类型。Vector的存储空间是连续的,list不是连续存储的。
定义和初始化：
vector< typeName > v1; //默认v1为空，故以下的赋值是错误的v1[0]=5;
vector
v2(v1); 或v2=v1;或vector
v2(v1.begin(), v1.end());//v2是v1的一个副本，若v1.size（）>v2.size()则赋值后v2.size()被扩充为v1.size()。
vector< typeName > v3(n,i);//v3包括n个值为i的typeName类型元素
vector< typeName > v4(n); //v4含有n个值为0的元素。
扩展资料
Vector类是在 java 中可以实现自动增长的对象数组，vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。
vector是C++标准模板库中的部分内容，中文偶尔译作“容器”，但并不准确。它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。
vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。
参考资料来源：百度百科-vector
参考资料来源：百度百科—向量
#include
#include
#include
using namespace std;
void main()
{
vector
vec;//定义个一个字符串容器
string str;
str = "abc";
vec.push_back(str);//把字符串str压进容器
vec.push_back("def");//把字符串"def"压进容器
vec.push_back("123");
for(int i=0; i
<vec.size(); i++)
{
cout<
<vec[i]<<endl; 打印容器的内容
}
vec.pop_back();//取出容器中最后一个
for(int i=0; i
<vec.size(); i++)
{
cout<
<vec[i]<<endl; 打印容器的内容
}
}
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可以自由规定排序规则。
string就是一个串类，在stl库中可以直接定义数据类型为string，而在c中只有字符类型和数组类型，串并不是一种类型，不过可以定义为字符数组来代替。
vector就是类似于一个数组的容器，内容比数组更加全面。很多操作都有自己的函数可以直接拿过来进行使用。主要函数就是：
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可以自由规定排序规则。
扩展资料
Vector类是在 java 中可以实现自动增长的对象数组，vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。
vector是C++标准模板库中的部分内容，中文偶尔译作“容器”，但并不准确。它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。
vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。
参考资料来源：百度百科-vector
</vec[i]<
</vec[i]<
c++ 用vector 定义二维数组
/**/#include
#include
#include
using namespace std;
void main()
{
vector
v;
vector < vector
> v2d;
v.push_back(1.0);
v.push_back(2.0);
v.push_back(3.0);
v.push_back(4.0);
v2d.push_back(v);
v.clear();/////////////////////
v.push_back(11.0);
v.push_back(12.0);
v.push_back(13.0);
v.push_back(14.0);
v2d.push_back(v);
for(int i=0;i
<v2d.size();i++)
{
for(int j=0;j
<v2d[i].size();j++)
cout<
<v2d[i][j]<<" ";
cout<
<endl;
}
}
1、在C++中，vector可以用来直接给二维数组赋值，比如我现在要给一个4 x 4的二维vector赋值，那么用如下代码实现：
#include
#include
using namespace std;
int main(){
vector
<vector
>nums = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
return 0;
}
2、可以用nums.size()和nums[0].size()来获取二维vector的行数和列数
在上述代码基础上添加
row = nums.size();
col = nums[0].size();
cout<<'rows = '<
<row<<endl;
cout<<'cols = '<
<col<<endl;
int a[3][4]={{1,2,3,4},{5,6,7,8},{2,3,4,5}};完全没问题
不过一般叫做多维阵列， multidimensional array
“二维”、“多维”数组在初级编程和解算法题时会被提到并流行
真正在实用中是较少用到的。实用中多用的是“装数组的数组”。
vector
<vector
> v;这个就是"二维"，可以用v.size()直接得到行数
*argv[] 这个也是"二维"。
</vector
</col<<endl;
</row<<endl;
</vector
</endl;
</v2d[i][j]<
c++中vector的使用要包含什么头文件
#include
using namespace std;
#include "Vector.h"
C++头文件之C、传统 C++
#include < assert.h>//设定插入点
#include < ctype.h> //字符处理
#include < errno.h> //定义错误码
#include < float.h> //浮点数处理
#include < fstream.h> //文件输入／输出
#include < iomanip.h> //参数化输入／输出
#include < iostream.h> //数据流输入／输出
#include < limits.h>//定义各种数据类型最值常量
#include < locale.h>//定义本地化函数
#include < math.h> //定义数学函数
#include < stdio.h> //定义输入／输出函数
#include < stdlib.h>//定义杂项函数及内存分配函数
#include < string.h>//字符串处理
#include < strstrea.h> //基于数组的输入／输出
#include < time.h> //定义关于时间的函数
#include < wchar.h> //宽字符处理及输入／输出
#include < wctype.h>//宽字符分类
C++头文件之标准 C++ （同上的不再注释）
#include < algorithm> //STL 通用算法
#include < bitset> //STL 位集容器
#include < cctype>
#include < cerrno>
#include < clocale>
#include < cmath>
#include < complex> //复数类
#include < cstdio>
#include < cstdlib>
#include < cstring>
#include < ctime>
#include < deque> //STL 双端队列容器
#include < exception> //异常处理类
#include < fstream>
#include < functional> //STL 定义运算函数（代替运算符）
#include < limits>
#include < list>//STL 线性列表容器
#include < map> //STL 映射容器
#include < iomanip>
#include < ios> //基本输入／输出支持
#include < iosfwd> //输入／输出系统使用的前置声明
#include < iostream>
#include < istream> //基本输入流
#include < ostream> //基本输出流
#include < queue> //STL 队列容器
#include < set> //STL 集合容器
#include < sstream> //基于字符串的流
#include < stack> //STL 堆栈容器
#include < stdexcept> //标准异常类
#include < streambuf> //底层输入／输出支持
#include < string> //字符串类
#include < utility> //STL 通用模板类
#include < vector> //STL 动态数组容器
#include < cwchar>
#include < cwctype>
using namespace std;
C++头文件之C99 增加
#include < complex.h> //复数处理
#include < fenv.h>//浮点环境
#include < inttypes.h>//整数格式转换
#include < stdbool.h> //布尔环境
#include < stdint.h> //整型环境
#include < tgmath.h> //通用类型数学宏