为什么很多人很多人都说不要在寂寞无聊的时候找女朋友？
我是个大二学生，自我评价很理性、很客观，但是一直不是很坚定，间歇性眼高手低，马上就要大三了，前两年也没干什么事，感觉想换一种生活，做点什么事：考研、考公务员，同时也觉得大学没谈恋爱挺遗憾的，也有寂寞无聊的成分在里面，正好借这个机会谈一次，也给自己一个目标，但是关于恋爱之后的发展一直没考虑过……
其实大部分都是因为寂寞无聊才开始一段恋情，有谁是真正准备好才开始的么？你只要记住一个原则，不要让女孩伤心难过，跟她在一起让她幸福就好，没有什么损失的人为什么会无聊呢？？？？？？？？
人为什么会无聊呢？？？？？？？？
补充：为什么一无聊就会找人聊天呢？
&无聊是一种不正常的心理状态。有了这种心理，人就会感到别扭、烦躁、空虚、难受、迷茫、无精打采，没有滋味，没有乐趣，坐立不安，提不起精神，不知道该干什么。现时代无聊的人不在少数。也许有人感到很纳闷，以前缺吃少穿的时候，感觉浑身有精神，生活有滋有味，现在生活富裕了，反倒感觉很难受。你说奇怪不奇怪？&&& 人和人的意识系统，都是世界上最复杂的事物、也最高层次的进化产物。个人作为一个整体，需要各种内外在的平衡。包括主体与环境的平衡，现实和理想的平衡，生理和心理的平衡、能力和欲望的平衡，还包括各种生理、心理和欲望之间的自我平衡，认识过程中的认知的平衡、比较中产生的情感的平衡等等，每种平衡的破坏，都会导致紧张不安或心理冲突。整体或综合平衡是身心健康的必要条件。各种心理防卫机制，就是为了维护心理的平衡，具有自我保护作用，能有效防止精神失调和崩溃。满足感是幸福感的要义之一。 &&& 那么，是不是越平衡越好呢？非也。动物的需要只有简单的生理、安全和繁衍需求，永远不会变化，此外别入他求，没有高级精神需要。也就是说动物的需要存在一个特定的界限。到达这个界限后不会再产生新的奢望。所以动物世界永远是那个样子，没有退步更没有进步。人类社会为什么会进化？是由于知识和经验的不断积累，工具和技能的不断进步。这些因素背后的推动力，就是不断变化、进步的人的欲望和需要。可以说人类欲望的不断进步和增长，导致了社会结构、物质财富的不断复杂和丰富。社会规律的存在，是每个人的欲望和行为的合力促成的。人的欲望的本性是喜新厌旧、贪得无厌、欲壑难填，永不知足，没有完结，无穷无尽。这存在于每个人的潜意识当中。它既是个人和社会进步的动力，往往也是导致痛苦的根源。为了不断满足推陈出新的各种需要，每个人都希望自己的能力不断长进，获取各种资源的本领越来越高，得到的东西越来越多。不平衡体现了不满、差异和梯度，而不满、差异和梯度正是变化和进步的动力。过于平衡就会丧失事物进步的动力，人的意识也会违拗潜意识而产生不舒服的感觉。所以最好的心理状态是平衡与不平衡的统一，既平衡又不过分平衡，以免丧失动力；既不平衡又不失调，以免心理崩溃。这种状态我称之为适当状态，也就是恰到好处的状态。人的欲望的恰当状态对人的心理健康能够具有极其重大的意义。&& 叔本华从人的欲望永远没有终结这一点，得出了人的欲望永远不能满足的结论，发出了人生就是痛苦的感叹。他看到了欲望不能满足所带来的烦恼，看到了欲望追求过程的的曲折性和最终满足的短暂性，但没有看到追求需要满足的过程所带来的兴奋和快慰。他的观点无疑有些消沉和偏激。&&& 马斯洛的需要层次论较好地说明了人类欲望、需求的结构层次和变化规律。他认为，人有五种基本需要，包括生理、安全、归属、自尊和自我实现的需要（后来他又增添了认知和审美的需要）。这五类需要分别属于不同的层次，并且具有不同的特征。生理和物质需要每人大体相同，并且比较容易满足；但这类需要的刚性很大，一旦不能满足将带来严重的痛苦和不安。精神需要差异很大，并且很不容易满足，需要能力、勤奋和成就来配合；同时这类需要有相当的弹性，即使没有达到相当的满足，也不至于过分痛苦。在这五类需求中，除了生理需求是生而有之外，其他需求都是随后逐步产生的。较低层次的需求是产生较高层次的基础和前提。低层次需求达到相当满足后，才能产生更高层次的需求。&&&&&&&& &&& 物质和财富极端匮乏的时候，很难产生无聊。为了生存，人们需要绞尽脑汁。对生存资料的追求欲望，极大地吸引了人们的注意力。心无二用。人们自然不会感到无聊。 && 改革开放为社会进步注入了活力。人们的生活有了很大改善。很多人过上了相当富裕的生活。人们不用为衣食发愁，不用为未来担忧。很多人满足于现在的好日子。没有新的追求，没有过高的奢望。按说这样的心理应该不错，知足常乐嘛。但是这违背了心理平衡和发展的基本规律。正常心理的产生，需要平衡和不平衡的协调与交替。生活需要紧张和轻松、知足和不满、劳作和休闲、平淡和刺激的相辅相成。如果生活过于平淡，过于轻松、过于知足，没有刺激，没有紧张，没有更高的追求，就会产生无聊情绪。“无事”必然“生非”。 &&& 人的潜意识中的欲望冲动需要对象化，人的精神能量需要释放渠道。一旦低层次需要达到满足，就需要利用更高层次的欲求，寻找和选择新的对象，开通新的释放渠道。然而很多人没有高层次追求，因而缺少新的对象和渠道，于是只能造成低层次需要的恶性膨胀和无限扩张，甚至利用不良刺激开辟发泄缺口。由此产生的无聊现象花样繁多。很多大款在比阔斗气。你点2万元的名菜，我要10万元的筵席；你买50万的丰田，我买100万的奔驰；你买几百万的别墅，我买几千万的豪宅。有的比奢侈出风头，婚丧嫁娶排场极大，奢侈无度；有的抢占风水宝地，大肆鼓捣祖坟；有的包养若干二奶，红旗不倒，彩旗飘飘；有的干脆拔掉红旗，吐故纳新，寻欢作乐。这些行为令人作呕，遭人唾骂。近来社会上积累的“仇富”心态，难道除了他们钱财的来路不正以外，就没有其它原因了吗？还有很多贪官污吏，眼看着升迁无望，便抱着有权不使过期作废的信条，明目张胆地胡作非为。他们随心所欲，肆意糟蹋国家钱财；生活糜烂，时常混迹于灯红酒绿；胆大妄为，挪用公款进行豪赌。其行为丑态百出，令人侧目。封建时代的皇帝老儿，权力无限，拥有一切，可以轻易得到任何希望得到的东西。什么大肆选美，拆散有情恋人；什么劳民伤财，建立豪华宫殿；什么穷兵黩武，给社会带来深重灾难。真可谓只有想不到的事情，没有不敢做的勾当。 &&& 马斯洛先生说，低层次需要满足后就能自发产生高层次的需要。可是为什么上面这些人在极其奢侈的情况下，没有产生高层次需要呢？为什么他们不会救济穷人，不去资助社会公益事业，或者从事一些有社会价值的事情呢？低层次需要的满足，只是产生高层需要的必要条件，但不是充分条件。一只老虎无论肚皮填得多饱，也不会产生仁慈和怜悯之心。人的知识、技能、欲望、资源、信仰、工具和价值观等因素之间，存在互为因果、互相促进、互相依赖和互相制约的关系。如果你的修养、观念、境界、价值观不高尚，那么无论你的钱财有多少，你的人格也只能停留在低度档次。你仍会受到无聊的折磨。 &&& 中华民族是一个灾难深重的民族。历史上我国人民长期处在水深火热之中，连起码的温饱都能难以保证，饱受生理性匮乏的严重折磨。对生存资料和物质财富强烈、迫切的渴望心态，深深地融进了文化传统和民族心理。这种心理极大地压抑了超越性精神追求的的萌芽和成长，造成了生理和物质欲望的畸形发展和恶性膨胀。社会秩序混乱，战乱接二连三；国人精于世故，盛产欺诈谎言，形成了国民急功近利和短视行为；加上封闭守旧，封建专制，各方面因素导致中国人很难产生求知求真、追求真善美、崇尚自由平等正义的超越性追求。所以，稍微富裕的中国人最容易产生无聊心理。&&& 理想、目标、目的都是近义词，用来表示人的欲望的对象。这个对象的有无、清晰与模糊、抽象与具体，对人的心理和精神状态具有重大的影响。有了追求的对象，并且比较清晰和具体，人的精神就会拥有支撑点，就会产生强烈的行为动力，内心就会感到充实。如果没有目标，或者相当模糊抽象，人就会感觉不舒服，就会产生无聊。根治无聊的方法，用一个形象的说法，就是要做到理想之灯永保光明。低层次需要满足了，那就要抓紧创造条件，有意识地培养高层次追求，拓宽理想伸展空间；旧的欲望满足了，新的欲求要随时与之接续；同时理想和欲求要尽可能具体、形象，最好能看得见摸得着，想得出办得到。这样它们就能更好地发挥激励和指向功能，从而有效防止无聊的捣乱。
相关知识等待您来回答
心理咨询领域专家
& &SOGOU - 京ICP证050897号百度拇指医生
&&&普通咨询
您的网络环境存在异常，
请输入验证码
验证码输入错误，请重新输入&&&&&& 这几天在做图像处理方面的研究，其中有一部分是关于图像分割方面的，图像目标在分割出来之后要做进一步的处理，因此有必要将目标图像的信息保存在一个变量里面，一开始想到的是数组，但是马上就发现使用数组的缺点：数组长度固定，动态分配内存很容易导致错误发生。最重要的一点是我要保存目标图像的每一点的坐标值，使用数组就有点无能为力了。因此到百度、Google大神上面找思路，终于被我发现在c++的标准库里面还有这么一个模板类：list，下面就是对找到的资料的汇总和加工。
vc6自带的msdn帮助文档的解释
以下是引自msdn帮助文档（中文是我自己翻译的，错误之处请包涵。）：
&&&& The template class describes an object that controls a varying-length sequence of elements of type T. The sequence is stored as a bidirectional linked list of elements, each containing a member of type T.
&&& 本模板类描述了一个对象，这个对象是类型为T的可变长度的序列元素。这个序列采用双向链表的方式存储每一个元素，其中每一个元素的数据流行都是T。
&&&& The object allocates and frees storage for the sequence it controls through a protected object named allocator, of class A. Such an allocator object must have the same external interface as an object of template class allocator. Note that allocatoris not copied when the object is assigned.
&&&& 对序列对象的分配和释放操作通过一个受保护的对象allocator进行。这样一个allocator对象必须有相同的外部接口作为一个模板类分配器的对象。注意：当对象被分配之后allocator不能被复制。
&&& List reallocation occurs when a member function must insert or erase elements of the controlled sequence. In all such cases, only iterators or references that point at erased portions of the controlled sequence become invalid.
&&& 当一个成员要进行insert或者erase操作时，列表的重新分配操作发生。在这种情况下，只有迭代器或者引用所指向的要删除的对象的指针变为无效。
msdn帮助文档自带的例子
下面为msdn帮助文档中自带的一个例子，该例展示了如何使用迭代器读取列表中的元素和进行插入操作。
#include &list&
#include &iostream&
using namespace
typedef list&int& LISTINT;
void main()
int rgTest1[] = {5,6,7};
int rgTest2[] = {10,11,12};
LISTINT listI
LISTINT listA
// Insert one at a time
listInt.insert (listInt.begin(), 2);
listInt.insert (listInt.begin(), 1);
listInt.insert (listInt.end(), 3);
for (i = listInt.begin(); i != listInt.end(); ++i)
cout && *i && " ";
// Insert 3 fours
listInt.insert (listInt.end(), 3, 4);
// 1 2 3 4 4 4
for (i = listInt.begin(); i != listInt.end(); ++i)
cout && *i && " ";
// Insert an array in there
listInt.insert (listInt.end(), rgTest1, rgTest1 + 3);
// 1 2 3 4 4 4 5 6 7
for (i = listInt.begin(); i != listInt.end(); ++i)
cout && *i && " ";
// Insert another LISTINT
listAnother.insert (listAnother.begin(), rgTest2, rgTest2+3);
listInt.insert (listInt.end(), listAnother.begin(), listAnother.end());
// 1 2 3 4 4 4 5 6 7 10 11 12
for (i = listInt.begin(); i != listInt.end(); ++i)
cout && *i && " ";
Program Output is:
1 2 3 4 4 4
1 2 3 4 4 4 5 6 7
1 2 3 4 4 4 5 6 7 10 11 12
list::list模板类的主要函数介绍
//给list赋值
back() //返回最后一个元素
begin() //返回指向第一个元素的迭代器
clear() //删除所有元素
empty() //如果list是空的则返回true
end() //返回末尾的迭代器
erase() //删除一个元素
front() //返回第一个元素
get_allocator() //返回list的配置器
insert() //插入一个元素到list中
max_size() //返回list能容纳的最大元素数量
merge() //合并两个list
pop_back() //删除最后一个元素
pop_front() //删除第一个元素
push_back() //在list的末尾添加一个元素
push_front() //在list的头部添加一个元素
rbegin() //返回指向第一个元素的逆向迭代器
remove_if() //按指定条件删除元素
remove() //从list删除元素
rend() //指向list末尾的逆向迭代器
resize() //改变list的大小
reverse() //把list的元素倒转
size() //返回list中的元素个数
sort() //给list排序
splice() //合并两个list
swap() //交换两个list
unique() //删除list中重复的元素
常用的操作主要是有插入操作、删除操作。list为实现头尾高效的插入和删除操作而提供了大多数的支持函数，而对于随机访问函数，则只能从头部或者尾部进行遍历操作。
关于remove和erase函数
上面的介绍中关于插入等等操作都有帮助的例子，但是对于删除函数，这个需要有一些注意的地方。下面请看例子：
#include &iostream&
#include &list&
#include &numeric&
#include &algorithm&
using namespace
//创建一个list容器的实例LISTINT
typedef list&int& TESTINT;
void main()
//使用TESTINT创建一个list类型的对象
//使用TESTINT创建一个迭代器对象
//从前面向listOne容器中添加数据
test.push_front (2);
test.push_front (1);
//从后面向listOne容器中添加数据
test.push_back (3);
test.push_back (4);
//从列表中删除一个元素
i = test.begin();
while(i != test.end())
int tmp = *i;
if(tmp == 2){
test.erase(i++);//在这里要是指针前进1个，否则迭代器失效
&&&&& 在使用list的时候不能使用随机访问的方式，只能按照迭代的方式进行访问，这样的话在进行删除操作的时候就可能会出现某一次删除操作之后指针没有指向下一个有效的元素而导致迭代器失效。因此，在进行删除操作时候最好使用while的方式,使用for循环如果控制不好，可能会导致迭代器失效。
&&&& 使用模版类可以极大的提高编程的效率，想想之前为了实现每个目标区域像素点的存取操作而使用这个方法都没有很好的解决问题，真后悔没有足够的知识积累，在此记录下来，共勉之。
下面的资料是在学习list模版类中找到的，以下内容均来自互联网。
C++ Lists（链表）
Lists将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢.
assign() 给list赋值back() 返回最后一个元素begin() 返回指向第一个元素的迭代器clear() 删除所有元素empty() 如果list是空的则返回true end() 返回末尾的迭代器erase() 删除一个元素front() 返回第一个元素get_allocator() 返回list的配置器insert() 插入一个元素到list中max_size() 返回list能容纳的最大元素数量merge() 合并两个list pop_back() 删除最后一个元素pop_front() 删除第一个元素push_back() 在list的末尾添加一个元素push_front() 在list的头部添加一个元素rbegin() 返回指向第一个元素的逆向迭代器remove() 从list删除元素remove_if() 按指定条件删除元素rend() 指向list末尾的逆向迭代器resize() 改变list的大小reverse() 把list的元素倒转size() 返回list中的元素个数sort() 给list排序splice() 合并两个list swap() 交换两个list unique() 删除list中重复的元素
附List用法实例：
#include &iostream&#include &list&#include &numeric&#include &algorithm&
//创建一个list容器的实例LISTINTtypedef list&int& LISTINT;
//创建一个list容器的实例LISTCHARtypedef list&char& LISTCHAR;
void main(void){&&& //--------------------------&&& //用list容器处理整型数据&&& //--------------------------&&& //用LISTINT创建一个名为listOne的list对象&&& LISTINT listO&&& //声明i为迭代器&&& LISTINT::
&&& //从前面向listOne容器中添加数据&&& listOne.push_front (2);&&& listOne.push_front (1);
&&& //从后面向listOne容器中添加数据&&& listOne.push_back (3);&&& listOne.push_back (4);
&&& //从前向后显示listOne中的数据&&& cout&&"listOne.begin()--- listOne.end():"&&&&& for (i = listOne.begin(); i != listOne.end(); ++i)&&&&&&& cout && *i && " ";&&& cout &&
&&& //从后向后显示listOne中的数据LISTINT::reverse_&&& cout&&"listOne.rbegin()---listOne.rend():"&&&&& for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) {&&&&&&& cout && *ir && " ";&&& }&&& cout &&
&&& //使用STL的accumulate(累加)算法&&& int result = accumulate(listOne.begin(), listOne.end(),0);&&& cout&&"Sum="&&result&&&&& cout&&"------------------"&&
&&& //--------------------------&&& //用list容器处理字符型数据&&& //--------------------------
&&& //用LISTCHAR创建一个名为listOne的list对象&&& LISTCHAR listT&&& //声明i为迭代器&&& LISTCHAR::
&&& //从前面向listTwo容器中添加数据&&& listTwo.push_front ('A');&&& listTwo.push_front ('B');
&&& //从后面向listTwo容器中添加数据&&& listTwo.push_back ('x');&&& listTwo.push_back ('y');
&&& //从前向后显示listTwo中的数据&&& cout&&"listTwo.begin()---listTwo.end():"&&&&& for (j = listTwo.begin(); j != listTwo.end(); ++j)&&&&&&& cout && char(*j) && " ";&&& cout &&
&&& //使用STL的max_element算法求listTwo中的最大元素并显示&&& j=max_element(listTwo.begin(),listTwo.end());&&& cout && "The maximum element in listTwo is: "&&char(*j)&&}
#include &iostream&#include &list&
typedef list&int& INTLIST;
//从前向后显示list队列的全部元素void put_list(INTLIST list, char *name){&&& INTLIST::
&&& cout && "The contents of " && name && " : ";&&& for(plist = list.begin(); plist != list.end(); plist++)&&&&&&& cout && *plist && " ";&&& cout&&}
//测试list容器的功能void main(void){//list1对象初始为空&&& INTLIST list1;&& &&& //list2对象最初有10个值为6的元素&&& INTLIST list2(10,6); &&& //list3对象最初有3个值为6的元素&&& INTLIST list3(list2.begin(),--list2.end());
&&& //声明一个名为i的双向迭代器&&& INTLIST::
&&& //从前向后显示各list对象的元素&&& put_list(list1,"list1");&&& put_list(list2,"list2");&&& put_list(list3,"list3");//从list1序列后面添加两个元素list1.push_back(2);list1.push_back(4);cout&&"list1.push_back(2) and list1.push_back(4):"&&&&& put_list(list1,"list1");
//从list1序列前面添加两个元素list1.push_front(5);list1.push_front(7);cout&&"list1.push_front(5) and list1.push_front(7):"&&&&& put_list(list1,"list1");
//在list1序列中间插入数据list1.insert(++list1.begin(),3,9);cout&&"list1.insert(list1.begin()+1,3,9):"&&&&& put_list(list1,"list1");
//测试引用类函数cout&&"list1.front()="&&list1.front()&&cout&&"list1.back()="&&list1.back()&&
//从list1序列的前后各移去一个元素list1.pop_front();list1.pop_back();cout&&"list1.pop_front() and list1.pop_back():"&&&&& put_list(list1,"list1");
//清除list1中的第2个元素list1.erase(++list1.begin());cout&&"list1.erase(++list1.begin()):"&&&&& put_list(list1,"list1");
//对list2赋值并显示list2.assign(8,1);cout&&"list2.assign(8,1):"&&&&& put_list(list2,"list2");
//显示序列的状态信息cout&&"list1.max_size(): "&&list1.max_size()&&cout&&"list1.size(): "&&list1.size()&&cout&&"list1.empty(): "&&list1.empty()&&
//list序列容器的运算&&& put_list(list1,"list1");&&& put_list(list3,"list3");cout&&"list1&list3: "&&(list1&list3)&&cout&&"list1&list3: "&&(list1&list3)&&
//对list1容器排序list1.sort();&&& put_list(list1,"list1");//结合处理list1.splice(++list1.begin(), list3);&&& put_list(list1,"list1");&&& put_list(list3,"list3"); }
补充：STL标准函数find进行vector 、list链表查找
#include &vector&#include &algorithm&#include &iostream&
class example{public:example(int val){i =}
bool operator==(example const & rhs){return (i == rhs.i) ? true :}
private:};int main(void){vector&example&ve.push_back(1);vector&example&::example elem(1);it = find(ve.begin(), ve.end(), elem);cout&&boolalpha&&(*it == elem);}
C++中的vector使用范例
vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector是一个容器，它能够存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，可以动态改变大小。
// c语言风格
int myHouse[100] ;
// 采用vector
vector&int& vecMyHouse(100);
当如上定义后，vecMyHouse就可以存放100个int型的数据了。
1. 它可以像普通数组一样访问
eg: vecMyHouse[50] = 1024;
2. 你可以顺序地向容器中填充数据
eg：int i =0 ;
for( ；i& 25; i++ )
vecMyHouse.push_back(1);
3. 它还可以动态地改变它的大小，通过下面这条语句实现
// 将容器的大小改为400,这样容器中就可以容纳400个int型数据了
eg:vecMyHouse.resize(400);
4. 你也可以在容器中装入自定义的数据类型
// 自定义一个class
class Cmyclass
// 定义一个存放class的容器
vector&Cmyclass& vecMyH
5. 你可以在定义容器时为它赋初值
// 定义一个容纳100个int型数据的容器,初值赋为0
vector&int& vecMyHouse(100,0);
6. 你可以把一个容器的对象赋值给另外一个容器
// 定义一个容纳100个int型数据的容器,初值赋为0
vector&int& vecMyHouse(100,0);
// 定义一个新的容器,内容与上述容器一样
vector&int& myV
myVec = vecMyH
二、 以上是vector容器的简单介绍，下面将详细介绍它的其他功能：
1. 为了使用vector，必须在你的头文件中包含下面的代码：
#include &vector&
2. vector属于std命名域的，因此需要通过命名限定，可以在文件开头加上
using std::
或者直接在使用vector的代码前加前缀
std::vector&int& myH
3. vector提供如下函数或操作：
下面列举了部分常用的功能
// 定义一个vector
std::vector&int&
// 可以使用的功能
c.clear() 移除容器中所有数据。
c.empty() 判断容器是否为空。
c.erase(pos) 删除pos位置的数据
c.erase(beg,end) 删除[beg,end)区间的数据
c.front() 传回第一个数据。
c.insert(pos,elem) 在pos位置插入一个elem拷贝
c.pop_back() 删除最后一个数据。
c.push_back(elem) 在尾部加入一个数据。
c.resize(num) 重新设置该容器的大小
c.size() 回容器中实际数据的个数。
c.begin() 返回指向容器第一个元素的迭代器
c.end() 返回指向容器最后一个元素的迭代器
三、下面描述一下什么是迭代器
迭代器相当于指针，例如：
// 对于变量而言，使用指针指向对应的变量
// 以后就可以使用 * 加指针来操作该变量了
int a = 10;
// 使用指针操作该变量
eg： *p = 11; // 操作后a变为 11
// 对于容器，使用迭代器操作容器中对应位置的值
// 当迭代器指向了容器中的某位置,则可以使用 * 加迭代器操作该位置了
// 定义一个vector
std::vector&int& myV
//添加10个元素
for(int j =0 ; j&10 ; j++)
myVec.push_back(j);
// 定义一个迭代器
std::vector&int&::
// 指向容器的首个元素
p = myVec.begin();
// 移动到下一个元素
// 修改该元素赋值
*p = 20 ; //& 则myVec容器中的第二个值被修改为了20
// 循环扫描迭代器,改变所有的值
p = myVec.begin();
for( ; p!= myVec.end(); p++ )
以上简单讲述了vector的用法，仅供入门之用,谢谢。
-------------------------------------------------------------------------------------
1.vector 的数据的存入和输出：
#include&stdio.h&
#include&vector&
#include &iostream&
void main()
int i = 0;
vector&int&
for( i = 0; i & 10; i++ )
v.push_back( i );//把元素一个一个存入到vector中
对存入的数据清空
for( i = 0; i & v.size(); i++ )//v.size() 表示vector存入元素的个数
cout && v[ i ] && " "; //把每个元素显示出来
注：你也可以用v.begin()和v.end() 来得到vector开始的和结束的元素地址的指针位置。你也可以这样做：
vector&int&::
for( iter = v.begin(); iter != v.end(); iter++ )
cout && *iter &&
2. 对于二维vector的定义。
1)定义一个10个vector元素，并对每个vector符值1-10。
#include&stdio.h&
#include&vector&
#include &iostream&
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 ] && " ";
2)定义一个行列都是变化的数组。
#include&stdio.h&
#include&vector&
#include &iostream&
void main()
int i = 0, j = 0;
vector& vector&int& & A
vector& int &
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 ] && " ";
使用 vettor erase 指定元素
#include "iostream"
#include "vector"
int main()
vector&int&
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);
cout && "After remove 8:\n";
for(vector&int&::iterator it = arr.begin(); it & arr.end(); ++it)
cout && * it && " ";
阅读(...) 评论()