C++语言里有哪些比较常见的坑？

前段时间给部门做了个C++专题的分享，主要分享了C++语言里一些常见的坑，在这里也分享给大家。

首先说下C++和C语言有什么区别？分享一个我在知乎上看见的回答：

C++ ≈ C with classes， C with STL

C：面向机器编程

C++：面向编译器编程

C++有个很重要的特性叫RAII，个人认为可以多多使用，相当方便，关于RAII巧妙使用可以看我这两篇文章《RAII妙用之ScopeExit》《RAII妙用之计算函数耗时》。

言归正传，下面我一个一个的列出来C++使用过程中常见的坑：

无符号整数的错误使用

for （unsigned int i = 10; i 》= 0; --i） { 。.. }

上面这段代码会发生什么？ 会死循环，这里要注意下无符号整数的使用。

容器的size（）返回类型是无符号整数

std：：vector《int》 vec;vec.push_back（1）;for （auto idx = vec.size（）; idx 》= 0; idx--） { cout 《《 “=====

”;}

这段代码依旧会出现死循环，原因参考上一条。

memcpy、memset只适用于POD结构

至于什么是POD类型，其实解释起来挺麻烦的，感兴趣的可以直接看cppreference的https://en.cppreference.com/w/cpp/named_req/PODType

STL遍历删除时注意迭代器失效问题

void erase（std：：vector《int》 &vec， int a） { for （auto iter = vec.begin（）; iter ！= vec.end（）;） { // 这个正确 if （*iter == a） { iter = vec.erase（iter）; } else { ++iter; } }

for （auto iter = vec.begin（）; iter ！= vec.end（）; ++iter） { // error if （*iter == a） { vec.erase（iter）; // error } }}

std：：list排序使用自己的成员方法

一般的容器排序都使用std：：sort（），但是list特殊。

int main（） { std：：list《int》 list{1， 2， 3， 2}; list.sort（）; // std：：sort（list.begin（）， list.end（））; for （auto i ： list） { std：：cout 《《 i 《《 “ ”; } std：：cout 《《 “

”; return 0;}

new/delete、new［］/delete［］、malloc/free严格配对

这几个一定要配对使用，原因的话可以看我之前的文章《new［］和delete［］为何要配对使用？》

基类析构函数要是虚函数

如果不是虚函数的话，可能会有内存泄漏的问题

注释用/**/，而不是//

注释用/**/，可能会出问题。原因：utf-8和ANSC（GB2312）编码混乱后，中文注释就乱码了，乱码中藏着 */，匹配错了，导致IDE实际注释的部分并非肉眼所见，定位极其困难，常见于Windows中。

成员变量初始化

成员变量没有默认初始化行为，需要手动初始化。

不要返回局部变量的指针或引用

char* func（） { char a［3］ = {‘a’， ‘b’， ‘c’}; return a;}

栈内存容易被污染。

浮点数判断是否相等问题

float f;if （f == 0.2） {} // 错误用法if （abs（f - 0.2） 《 0.00001） {} // 正确用法

vector clear和swap问题

清空某个vector，可以使用swap而不是其clear方法，这样可以更早的释放vector内部内存。

vector《int》 vec;vector《int》（）.swap（vec）;vec.clear（）;

vector问题

尽量不要在vector中存放bool类型，vector为了做优化，它的内部存放的其实不是bool。

条件变量

条件变量的使用有两大问题：信号丢失和虚假唤醒，相当重要，具体可以看我这篇文章《使用条件变量的坑你知道吗》。

类型转换

在C++中尽量使用C++风格的四种类型转换，而不要使用C语言风格的强制类型转换。

异步操作中async的使用

std：：async（std：：async， ［］{ f（）; }）; // 临时量的析构函数等待 f（）std：：async（std：：async， ［］{ g（）; }）; // f（） 完成前不开始

std：：async 这货返回的 future 和通过 promise 获取的 future 行为不同，async 返回的 future 对象在析构时会阻塞等待 async 中的线程执行完毕，这就导致在大部分场景中 async达不到你直觉的认为它能达到的目的。

智能指针

一个裸指针不要使用多个智能指针包裹，尽可能使用make_unique，make_shared。

当需要在类得内部接口中，需要将this作为智能指针使用，需要用该类派生自enable_shared_from_this

栈内存使用

合理使用栈内存，特别是数组，数组越界问题容易导致栈空间损坏，可以考虑使用std：：array替代普通的数组。

std：：thread的使用

一定要记得join或这detach，否则会crash。

void func（） {}int main（） { std：：thread t（func）; if （t.joinable（）） { t.join（）; // 或者t.detach（）; } return 0;}

enum使用

尽量使用enum class替代enum，enum class 是带有作用域的枚举类型。

空指针使用nullptr而不是NULL

至于为什么要这么使用，可以看我这篇文章《关于nullptr这篇文章你一定要看》

void func（char*） { cout 《《 “char*”;}void func（int） { cout 《《 “int”;}

int main（） { func（NULL）; // 编译失败 error： call of overloaded ‘func（NULL）’ is ambiguous func（nullptr）; // char* return 0;}

std：：remove的使用

这个remove其实并没有真正的删除元素，需要和erase配合使用，跑一下这段代码就知道啦。

bool isOdd（int i） { return i & 1; }

void print（const std：：vector《int》& vec） { for （const auto& i ： vec） { std：：cout 《《 i 《《 ‘ ’; } std：：cout 《《 std：：endl;}

int main（） { std：：vector《int》 v = {0， 1， 2， 3， 4， 5， 6， 7， 8， 9}; print（v）;

std：：remove（v.begin（）， v.end（）， 5）; // error print（v）;

v.erase（std：：remove（v.begin（）， v.end（）， 5）， v.end（））; print（v）;

v.erase（std：：remove_if（v.begin（）， v.end（）， isOdd）， v.end（））; print（v）;}

全局变量初始化问题

不同文件中的全局变量初始化顺序不固定，全局变量尽量不要互相依赖，否则由于初始化顺序不固定的问题，可能会导致bug产生。

原文标题：C++的24个大坑，你能躲过几个？

文章出处：【微信公众号：嵌入式ARM】欢迎添加关注！文章转载请注明出处。

责任编辑：haq