C++博客-Daywei0123-随笔分类-C/C++

SDL认识

Daywei — Mon, 27 Jun 2016 16:17:00 GMT

SDL是一个轻量级的，用C语言开发的多媒体库。它包含了图像绘制、文字绘制、事件处理、声音播放等模块。因为SDL的易用以及它的扩展库的完整性，很多2D游戏都使用SDL开发，其中就包括这几年大热的移动平台上的游戏《愤怒的小鸟》。

然后说说从个人角度上看SDL的特点。

1.跨平台。确确实实是跨了N个平台，甚至包括NDS这种平台。有了SDL，你甚至可以在windows、linux、Android上任意移植你的游戏。当然，前提是你目标平台的编译器认识你的代码(￣▽￣)”。有了SDL泥甚至可以只用c语言开发安卓游戏哟。

2.开源。

3.SDL2.0绘图效率很高。事实上相较之SDL1.2我个人比较喜欢SDL2.0的原因也是在此。个人感觉（其实我没看过源码）SDL1.2应该是个跟当年的DirectDraw差不多的东西，像素填充什么的，有相当程度上是要磨CPU的。而SDL2.0从绘图方式上就革新了，抛弃了之前的surface与clip的模式，把实际绘制的东西改为了Texture，而把之前的surface改为了创建Texture的一个临时环节。而texure，顾名思义，其实就是DirectX、OpenGL这些底层的3D硬件加速API的贴图。

当下DirectX、OpenGL标准下的显卡的渲染管线无非就是：1.把顶点（可以理解成坐标）传给显卡。2.把texture传给显卡。 3.告诉显卡怎么处理这些数据（shader）。 4.显卡把东西给你显示出来。而基于DirectX、OpenGL(移动平台是OpenGL ES)的SDL2.0，正是恰好地利用了当下显卡的能力。

4.SDL可以用作3D图像引擎和底层DirectX/OpenGL API的中间层。当然，其实如果把SDL这样用的话，那就真是很薄的一层了：）

5.易用。这是相对而言的，比如在windows上，你用了SDL这个库之后，基本就不用去理会Windows那些又臭又长用不着的参数又多的API了。我不是在讨论信仰问题也不是要诋毁windows，我是在客观陈述windows api那个要初始化一个窗口必须要堆100行代码的设定实在是打击初学者积极性的事实。

SDL_image、SDL_ttf、SDL_mixer、SDL_net 外部扩展库，也是不错的选择。

性能没有测试，仅从写代码角度上来说，个人感觉2.0将操作给弄得复杂了。

1.2---------------------------------------
只有SDL_Surface的概念，屏幕是surface，图片，文字等都是surface，
只要将准备好的各种图片，贴到屏幕里去(SDL_BlitSurface)；再刷一下屏幕(SDL_Flip全局的、或SDL_UpdateRect局部的)就ok了。。。

SDL_Init(SDL_INIT_EVERYTHING);

SDL_Surface* screen = SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE);
SDL_Surface* bmp = SDL_LoadBMP("back.bmp");
SDL_BlitSurface(bmp, 0, screen, 0);
SDL_Flip(screen);

while(SDL_WaitEvent(&e)) {
switch(e.type) {
case SDL_QUIT:
return;
}
}
SDL_Quit();
2.0---------------------------------------
整出了SDL_Window,SDL_Renderer,SDL_Texture新的3个东西。
并且我要画一张图，先要得到surface，然后转换为texture，再临时贴到renderer，最后才刷屏。

SDL_Init(SDL_INIT_EVERYTHING);

SDL_Window* window = SDL_CreateWindow("hello", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, SDL_WINDOW_SHOWN);
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
SDL_Surface* surface = SDL_LoadBMP("back.bmp");
SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
SDL_RenderClear(renderer);
SDL_RenderCopy(renderer, texture, 0, 0);
SDL_RenderPresent(renderer);

while(SDL_WaitEvent(&e)) {
switch(e.type) {
case SDL_QUIT:
return;
}
}
SDL_Quit();

其实，我真心不觉得提出SDL_Window,SDL_Renderer,SDL_Texture这些概念先进性在哪里？可能是与openGL的概念保持一致吧。
而且从维护的角度出发，不管sdl2.0性能提升了多少，如果接口本身不需要改动，不是更加好么？

---------------------------------------------
最后我发现，同样是渲染的窗口
1.2用SDL_Flip(screen);之后被其他窗口挡住之后，回来画面还是在的；
2.0用SDL_RenderPresent(renderer);之后被其他窗口挡住之后，回来画面就不在了；

Daywei 2016-06-28 00:17 发表评论

Exceptional C++ 读书笔记2

Daywei — Fri, 22 Aug 2014 07:00:00 GMT

永远不要用#include包含不必要的头文件

如果只需要流的前置声明，应该优先使用#include

只需要前置声明时，绝不要用#include包含相应的头文件。

如果使用聚合关系就已经足够，就不要使用继承。

要避免使用内联或者复杂的调整方法，除非通过性能分析证明这确实是必要的。

正确使用名字空间。如果将一个类放入名字空间，那么同时要保证将这个类的所有辅助函数和运算符函数也放入相同的名字空间。否则，你将在代码中发现奇怪的结果。
要理解这五种不同类型的内存，了解他们为什么是不同的，以及他们各自的行为又是怎么样：栈（自动变量）、自由存储（new/delete）、堆（malloc/free）、全局（静态变量、全局变量、文件作用域变量等）、常量数据（字符串常量等）。

优先使用自由存储（new/delete），避免使用堆（malloc/free）。

对于“堆”和“自由存储”进行区分，这一点很重要，因为在C++标准中有意避开了这两种类型的内存是不是相关的这个问题。例如，当通过：：operator delete()函数来释放内存时，在C++标准的18.4.1.1中，最后一项是这样的：
“ 在C++标准中并没有规定，在哪些情况下，在通过operator delete回收的存储空间中，有一部分或者全部的控件可以再随后调用operator new或者calloc，malloc以及realloc等函数时被重新分配，这些函数的声明时在中。”
而且，在C++标准中也没有规定，new/delete是否需要通过malloc/free来实现。不过，在C++标准20.4.6节的第3段和第4段中规定了，malloc/free一定不能使用new/delete来实现：“calloc、malloc和realloc函数不会通过调用::operator new()来分配存储空间。函数free（）不会通过调用::operator delete() 来释放内存。”

如果在类中定义了new和delete中的任意一个运算符函数，那么一定要同时定义另外一个。

通常应该显式地将函数operator new ()和operator delete()声明为静态函数。他们永远都不能使非静态成员函数。

永远都不要通过多态的方式处理数组。

优先选择使用vector或者deque，而不是数组。

在编写拷贝赋值运算符函数时，永远都不要指望能够通过对自我赋值进行检测来保证函数的正确性；应该在拷贝赋值运算符函数中使用“创建临时对象并进行交换”的惯用法，这种方法不仅是异常安全的，而且在处理自我赋值时也是安全的。

可以将自我赋值检测作为一种优化手段，以避免不必要的工作，这是正确地做法。

不仅要避免编写类型转换运算符函数，而且还要避免编写隐式的构造函数。

尽量编写异常安全的代码。在编写代码时应该始终遵循：即使在出现异常时，资源仍然能够被正确地释放，并且数据也总是处于一致的状态。

避免使用语言中那些不常用的特性，而应该使用最简单并且有效的技术。

拷贝初始化过程绝不是赋值过程，因此在初始化中永远都不会调用函数T::operator=()。是的，我知道在初始化语句中有一个“=”符合，但不要被它迷惑。它只是从C语言中沿用过来的一种语法，并不代表赋值运算。

如果可能的话，优先使用“T t(u);”这种形式，而不是“T t=u;”的形式。通常，能能够时候后者的地方，都可以使用前者，并且使用前者还有更多的好处——例如，可以带多个参数。

在函数声明中，如果参数是以传值方式来传递的，则不要使用const。而如果在这个函数的定义中，参数是不能被修改的，那么应该使用const。

对于不是内置类型的返回值来说，当使用返回值的方式而不是返回引用的方式时，应该优先选择返回const值。

const 和mutable都是你的朋友

优先使用新形式的类型转换。

不要通过类型转换去掉常量属性，而应该使用mutable。

避免使用向下的类型转换。

优先通过引用方式来传递对象参数，而不是传值方式，并且在所有可能的地方都使用const。

避免使用内联，除非从性能的分析上来看确实有必要这么做。

避免使用全局变量或者静态变量。如果必须使用，那么一定要特别注意这些变量的初始化顺序。

在构造函数的初始化列表中，应该把基类按照他们在类定义中出现的先后顺序进行排列。

在编写代码时，永远都不应该依赖函数参数的求值顺序

Daywei 2014-08-22 15:00 发表评论

Exceptional C++ 读书笔记1

Daywei — Fri, 22 Aug 2014 03:50:00 GMT

绝对不要对无效的迭代器执行解引用（dereference）操作

用于不要将异常安全性放在事后考虑。异常安全性会影响到类的设计。它永远都不会“只是一个实现细节”。

在传递对象参数时，选择const&方式而不是传值方式。

对于程序运行中不会改变的值，应该预先计算并保存起来备用，而不是重复地创建对象，这是没有必要的。

通常，为了保持一致性，应该使用前置递增来实现后置递增，否则，当其他用户在使用你的类时，可能会得到奇怪结果。

优先选择使用前置递增。只有在需要初始值时，才使用后置递增。

在进行隐式类型转换时，要注意在转换过程中创建的临时对象。要避免这个问题，一个好办法就是尽可能地通过显式的方式来构造对象，并避免编写类型转换运算符。

记住对象的生存期。永远，永远，永远都不要返回指向局部对象的指针或引用；它们没有任何用处，因为主调代码无法跟踪它们的有效性，但却可能会试图这么做。

尽可能地重用代码——尤其是标准库中的代码——而不是自己去编写代码，这样更快、更容易，也更安全。

如果在函数中不打算处理所抛出的异常，那么应该将异常转发给能够进行处理的上层调用者。

在编写代码时应该始终遵循：即使在出现异常时，资源仍然能够被正确地释放，并且数据也总是处于一致的状态。

遵循标准的异常安全规则：永远不要在析构函数、重载运算符函数operator delete()或者operator delete[]()中抛出异常；在编写每个析构函数和内存释放函数时，要假设存在着“throw()”这样的异常规范。

遵循标准的异常安全性规则：在每个函数中，要将所有可能会抛出异常的代码单独放在一起，并且对这些代码进行安全处理。然后，当你确认这些代码执行的工作都已经成功地完成时，才可以使用不会抛出异常的操作来修改程序的状态。

永远都不要到最后才实现异常安全性。异常安全性会对类的设计产生影响。它永远都不会“只是一个实现细节”。

优先考虑实现内聚。要努力使每段代码——每个模块、每个类、每个函数——都只有单一的，并且是明确定义的功能。

“异常不安全”总是与“拙劣的设计”结伴的。如果程序的设计逻辑清晰，那么即使有一段代码不是异常安全的，一般来说也不会有太大问题，并且可以很简单地进行修正。但如果有一段代码由于设计问题而不能被编写成异常安全的，我们通常都会认为这个设计时拙劣的。下面是两个拙劣设计的示例。
示例1：如果在一个函数中需要实现两个不同的功能，那么这个函数很难被编写成异常安全的。
示例2：如果在拷贝赋值运算符函数中必须对自我赋值进行检测，那么这个函数也可能不是完全异常安全的

遵循标准的异常安全性规则：以“获得资源也就意味着初始化”这种模式来分离资源的所有权和资源的管理权。

在进行设计中，要始终牢记重用性。

优先采用“ a op=b;”这种写法，而不是"a = a op b;"（这里的op表示某个运算符）。这种写法更为清晰，效率也高。

如果定义了某个运算符（例如，operator+），那么通常还应该同时定义与这个运算符相对应的赋值运算符（例如，operator+=）。并且用后者来实现前者。而且，还应该维护op和op=之间的自然关系。

在C++标准中规定：运算符=，（），[]和->必须被定义为成员函数，而在类中定义的new,new [],delete和delete[]等运算符函数必须是静态成员函数。对于其他的运算符函数：
如果运算符函数是用于流I/O的opeator>>或者operator<<，或者如果运算符函数需要对其左操作数进行类型转换，或者运算符函数可以通过类的公有接口来实现，那么将这个函数定义为非成员函数（在前两种情况中，如果需要的话也可以被定义为友元函数）；如果运算符函数需要实现虚函数的行为，那么增加一个虚函数来提供虚函数的行为，并用这个虚成员函数来实现运算符函数否则将预算富函数定义为成员函数。

在函数opeator>>和operator<<中应该始终返回对流对象的引用。

将基类的析构函数定义为虚函数（除非你能保证，永远都不会有人通过指向基类的指针来删除派生类的对象）。

如果在派生类中定义的函数与基类中的函数有相同的名字，并且你不想隐藏基类中函数，那么应通过using声明语句将基类的这个函数引入到派生类的作用域中。

永远不要改变被覆盖的基类函数中的默认参数值。

除了对真正的Liskov IS-A和WORKS-LIKE-A关系进行建模之外，永远都不要使用共有继承。所有被覆盖的成员函数不能超过实际需求的范围，同时也不能小于这个范围。

使用公有继承的目的是重用代码（编写以多态的方式使用基类对象的代码），而重用（基类中的）代码并不一定要使用公有继承。

对“is implemented in terms of”这种关系建模时，应该优先选择成员关系/包含的方式，而不是私有继承的方式。只有非用继承不可时，才应该使用私有继承——也就是说，当需要访问保护成员或者需要覆盖虚函数时，才使用私有继承。永远都不要只是为了代码重用而使用共有继承。

对于广泛使用的类，应该优先使用编译器防火墙这种惯用法（也叫做Pimpl惯用法）来隐藏实现细节，通过一个不透明的指针（指向一个进行了前置声明但又没有定义的类）来保存私有成员（包括状态变量和成员函数），声明这个指针时可采用“struct XxxxImpl* pImpl;XxxxImpl* pimpl_;”这样的形式。例如：“class map{ private :struct MapImpl;MapImpl* pimpl_;}”

包含，也可以叫做“聚合”，“分层”，“HAS-A”或者“委托”。优先选择包含而不是继承，对于IS-IMPLEMENTED-IN-TERMS-OF这种关系建模时，应该优先考虑使用包含，而不是继承。

Daywei 2014-08-22 11:50 发表评论

从缺陷中学习C/C++

Daywei — Thu, 24 Jul 2014 07:29:00 GMT

有符号int与无符号int比较的后果

int i = -1;
unsigned int ud=1;
if(i < ud)
{
printf("true");
}
else
{
printf("false");
}

一看结果应该是打印出true，但事实却是false。
signed int 型变量被转换成unsigned int型变量。-1转换成unsigned int的结果是一个非常巨大的正整数（32位系统上是2的32次方-1），需要进行强转为int型。

位域变量

struct data
{
int flag:1;
int other:31;
};
printf("data size %d\n",sizeof(data));
data test1;
test.flag = 1;
if(test.flag ==1)
{
printf("true");
}
else
{
printf("false");
}

int的位域变量，而用一个bit表示int时，这一位是用来表示有符号位的，带符号的一个bit的位域变量的取值范围是0或-1.无符号的一个bit的位域变量的取值范围是0或1，故1赋给flag时会出现溢出，flag变为-1.
Reference：http://wenku.baidu.com/view/670eff4bf7ec4afe04a1dfd7.html

Daywei 2014-07-24 15:29 发表评论

Effective STL(5)——算法

Daywei — Wed, 25 Jun 2014 09:06:00 GMT

1.确保目标空间足够大

2.了解各种与排序有关的选择
如果需要对vector、string、deque或者数组中的元素执行一次完全排序，那么可以使用sort或者stable_sort。
如果有一个vector、string、deque或者数组，并且只需要对等价性最前面的n个元素进行排序，那么可以使用partial_sort。
如果有一个vector、string、deque或者数组，并且需要找到第n个位置上的元素，或者，需要找到等价性最前面的n个元素但又不必对这n个元素进行排序，那么，nth_element正是你所需要的函数。
如果需要将一个标准序列容器中的元素按照是否满足某个特定的条件区分开来，那么，partition和stable_partition可能正是你所需要的。
如果你的数据在一个list中，那么你仍然可以直接调用partition和stable_partition算法；可以用list::sort来替代sort和stable_sort算法。但是，如果你需要获得partial_sort或nth_element算法的效果，那么，正如前面我所提到的那样，你可以有一些简洁的途径来完成这项任务。

3。如果确实需要删除元素，则需要在remove这一类算法之后调用erase。

remove不是真正意义上的删除，因为它做不到。

4.对包含指针的容器使用remove这一类算法时要特别小心。会导致资源泄露。

5.了解哪些算法要求使用排序的区间作为参数。

6.通过mismatch或lexicographical_compare实现简单地忽略大小写的字符串比较

7.理解copy_if算法的正确实现

8.使用accumlate或者for_each进行区间统计。

Daywei 2014-06-25 17:06 发表评论

Effective STL(4)——迭代器

Daywei — Fri, 13 Jun 2014 07:00:00 GMT

1.iterator 优先于const_iterator、reverse_iterator及const_reverse_iterator

2.使用distance和advace将容器的const_iterator转换成iterator

3.正确理解由reverse_iterator的base（）成员函数所产生的iterator的用法。

4.对于逐个字符的输入请考虑使用istreambuf_iterator

Daywei 2014-06-13 15:00 发表评论

Effective STL(3)——关联容器

Daywei — Fri, 16 May 2014 08:30:00 GMT

1.理解相等（equality）和等价（equivalence）的区别

相等的概念是基于operator==的。等价关系是以“在已排序的区间中对象值得相对顺序”为基础的。如果从每个标准关联容器的排列顺序来考虑等价关系，那么着将是有意义的。标准关联容器室基于等价而不是相等的。标准关联容器总是保持排列顺序的，所以每个容器必须有一个比较函数（默认less）来决定保持怎样的顺序。等价是按照比较函数子。因此，标准关联容器的使用者要为所使用的每个容器指定一个比较函数（用来决定如何排序）。如果该关联容器使用相等来决定两个对象是否有相同的值，那么每个关联容器除了用于排序的比较函数外，还需要另一个比较函数来决定两个值是否相等（默认情况下，该比较函数应该是equal_to，但有趣的是equal_to从来没有被用做STL的默认比较函数。当STL中需要相等判断时，一般的惯例是直接调用operator==。比如，非成员函数find算法就是这么做的）

2.为包含指针的关联容器指定比较类型

why？第一条已经说明关联容器是要排序。每当你要创建包含指针的关联容器时，一定要记住，容器将会按照指针的值进行排序。一般是不是你希望的，所以你几乎要创建自己的函数子类作为该容器的比较类型。

3.总是让比较函数在等值情况下返回false

比较函数的返回值表明的是按照该函数定义的排列顺序，一个值是否在另一个之前。相等的值从来不会有前后顺序关系，所以，对于相等的值，比较函数应该始终返回false。

4.切勿直接修改set或multiset中的键。

5。考虑用排序的vector替代关联容器

在排序的vector中存储数据可能比在标准关联容器中存储同样的数据要耗费更少的内存，而考虑到页面错误的因素，通过二分搜索法来查找一个排序的vector可能比查找一个标准关联容器要更快一些。

6.当效率至关重要时，请在map::operator[]与map::insert之间谨慎做出选择

map::operator[]的设计目的是为了提供“添加和更新”的功能。添加一个新元素最好选后者insert。

7.熟悉非标准的散列容器。

Daywei 2014-05-16 16:30 发表评论

Effective STL (2)——vector 和 string

Daywei — Sun, 20 Apr 2014 06:10:00 GMT

1.vector和string优先于动态分配的数组。

2.使用reserve来避免不必要的重新分配
    关于stl容器会自动增长以便容纳下你放入其中的数据，只要没有超过它们的最大限制就可以。对于vector和string，增长过程是这样实现的：每当需要更多空间时，就调用与realloc类似的操作。这一类似于relloc的操作分为如下4部分：
        （1）分配一块大小为当前容量的某个倍数的新内存。在大多数实现中，vector和string的容量每次以2的倍数增长，即每当容器需要扩张时，它们的容量即加倍。
         （2）把容器的所有元素从旧的内存复制到新的内存中。
         （3）析构掉旧内存中的元素
         （4）释放旧内存
    reserve成员函数能使你把重新分配的次数减少到最低限度，从而避免了重新分配和指针迭代器引用失效带来的开销。
    简单概括一下四个相互关联、但有时会被混淆的成员函数。在标准容器中，只有vector和string提供了所有这四个函数：
         （1）size（）告诉你容器中有多少个元素，它不会告诉你该容器为自己所包含的元素分配了多少内存。
         （2）capacity（）告诉你容器利用已经分配的内存可以容纳多少元素。这是容器所能容纳的元素总数，而不是它还能容纳多少个元素。如果你想知道一个vector有多少未被使用的内存，就得从capacity（）中减去size（）。如果size和capacity返回同样的值，就说明容器中不再有剩余空间了，因此下一个插入操作（push_back）将导致上面所提到的重新分配过程。
         （3）resize（xx）强迫容器改变到包含n个元素的状态。在调用resize之后，size将返回n。如果n比当前的大小（size）要小，则容器尾部的元素将会被析构掉。如果n比当前的大小要大，则通过默认构造函数创建的新元素将被添加到容器的末尾。如果n比当前的容量要大，那么在添加元素之前，将先重新分配内存。
          （4）reserve（xx）强迫容器把它的容量变为至少是n，前提是n不小于当前的大小。这通常会导致重新分配，因为容量需要增加。（如果n比当前的容量小，则vector什么也不做）
       因此，避免重新分配的关键在于，尽早的只用reserve，把容器的容量设为足够大的值，最好是在容器刚被构造出来之后就使用reserve。

3.注意string实现的多样性

4.了解如何把vector和string数据传给旧的API

5.使用“swap技巧”除去多余的容量。

6.避免使用vector
    vector不是一个stl容器，也不存储bool。在一个典型的实现中，储存在vector中的每个bool仅占一个二进制位，一个8位的字节可容纳8g个“bool”。在内部vector使用了与位域一样的思想，来表示它所存储的那些bool；实际上只是假装存储了这些bool。
     vector不完全满足STL容器的要求；你最好不要使用它；你可以使用deque和bitset来替代它，这两个数据结构几乎能做vector所能做的一切事情。

Daywei 2014-04-20 14:10 发表评论

Effective STL （1）

Daywei — Fri, 04 Apr 2014 13:10:00 GMT

慎重选择容器类型
标准序列容器：vector string deque list
标准关联容器 : set multiset map multimap
非标准序列容器: slist rope. slist 是一个单向链表，rope 本质上市一个“重型”string
非标准的关联容器 hash_set hash_nultiset hash_map hash_multimap vector 作为string的替代。 vector 作为标准关联容器的替代
几种标准的非STL容器包括数组、bitset valarray stack queue 和 priority_queue

容器可分类为连续内存容器和基于节点的容器

连续内存容器把它的元素存放在一块或多块（动态分配的）内存中，每块内存中存有多个元素。当有新元素插入或已有的元素被删除时，同一内存块中的其他元素要向前或向后移动，以便为新元素让出空间，或者填充被删除元素所留下的空隙。
基于节点的容器在每一个（动态分配的）内存块中只存放一个元素。容器中元素的插入或删除只影响到指向节点的指针，而不影响节点本身的内容，所以当有插入或删除操作时，元素的值不需要移动。

你是否需要在容器的任意位置插入新元素？如果需要，就选择序列容器；关联容器是不行的。
你是否关心容器中的元素师排序的？如果不关心，则哈希容器室一个可行的选择方案；否则，你要避免哈希容器。
容器中数据的布局是否需要和C兼容？如果需要兼容，就只能选择vector。
元素的查找速度是否是关键的考虑因素？如果是，就要考虑哈希容器、排序的vector和标准关联容器——或许这就是优先顺序。

确保容器中的对象拷贝正确而高效

调用empty而不是检查size（）是否为 0
理由很简单：empty对所有的标准容器都是常数时间操作，而对一些list实现，size耗费线性时间。由于list所独有的链接操作。

区间成员函数优先于与之对应的单元素成员函数。

如果容器中包含了通过new操作创建的指针，切记在容器对象析构前将指针delete掉。切勿创建包含auto_ptr的容器对象。问题的根源只是在于auto_ptr不是这样的智能指针。
永远都不要错误的认为：你可以通过创建auto_ptr的容器使指针被自动删除。

慎重选择删除元素的方法
erase是指向紧随被删除元素的下一个元素的有效迭代器。

要删除容器中有特定值得所有对象
如果容器使vector、string或deque，则使用earse-remove习惯用法。
如果容器是list，则使用list::remove
如果容器是一个标准关联容器，则使用它的erase成员函数。

要删除容器中满足特定判别式（条件）的所有对象
如果容器是vector、string或deque，则使用erase-remove_if的习惯用法。
如果容器是list，则使用list::remove_if。
如果容器使一个标准关联容器，则使用remove_copy_if和swap，或者写一个循环来遍历容器中的元素，记住当把迭代器传给erase时，要对它进行后缀递增。

要在循环内部做某些（除了删除对象之外的）操作
如果容器使一个标准序列容器，则写一个循环来遍历容器中的元素，记住每次调用erase时，要用它的返回值更新迭代器。
如果容器是一个标准关联容器，则写一个循环来遍历容器中的元素，记住当把迭代器传给erase时，要对迭代器作后缀递增。

切勿对STL容器的线程安全性有不切实际的依赖。

你不能指望STL库会把你从手工同步控制中解脱出来，而且你不能依赖于任何线程的支持。
在容器所返回的每个迭代器的生存期结束前，都锁住容器
对于作用于容器的每个算法，都锁住该容器，直到算法结束。多个线程读是安全的
多个线程对不同的容器作写入操作时安全的。
对容器成员函数的每次调用，都锁住容器直到调用结束。

Daywei 2014-04-04 21:10 发表评论