C++干货
项目实用的C++知识
之前看到的，不过自己整理了下。方便以后查找。
如下：
允许重载：函数名相同，参数类型不同，参数个数不同，即可重载，使用见下面代码：
#include namespace：namespace是什么？其实就相当于为变量和函数划个范围.如果不加namespace会有什么问题：
// namespace.cc
#include 结果大家可能都知道，这样的代码编译会报错：redefinition of ‘func’;一般规定一个程序内不允许同一个强符号有多个定义，那怎么解决？可使用namespace：
// namespace.cc
#include 这样编译成功，加入namespace后其实对编译器来说就是两个不同的函数，因为生成的是两个不同的符号
注意：不要过多using namespace xxx，例如using namespace std；可能就容易引起符号冲突问题，可以使用using std::cout这种方式。
class & struct：
很多面试官可能都会问class和struct的区别？具体答案我这里就不贴出来了，大家自己搜索答案就可，或者留言问我，它俩在C++里其实没什么区别，就是默认权限不同而已。
这里需要掌握几个知识点：
- 如何定义一个类
- 构造函数的定义及使用
- 析构函数的定义及使用
- 拷贝构造函数的定义及使用
- 移动构造函数的定义及使用
- 赋值构造函数的定义及使用
- 移动赋值函数的定义及使用
下面贴出一段示例代码：
// class.cc
#include 模板
模板主要分为函数模板和类模板，下面有示例代码：
// template.cc
#include 引用：C++里多了个引用的概念，很多人面试应该有被问到过引用和指针有什么区别吧？
关于指针和引用，在这里强烈推荐大家阅读《面试系列之指针和引用的使用场景》这篇文章，通俗易懂的纯干货型文章。
大家可以记住一个关键点就是引用追求从一而终，它的指向永远不会变，而指针是个善变的东西，它的指向随时可以改变，一般开发中会使用const &方式进行参数传递，省去不必要的对象拷贝：
多态：这是C++语言所支持的或者说面向对象的一个重要特性，直接看代码：
// polymorphic.cc
#include 这里简单介绍了实现多态的两种方式：通过指针或者通过引用。
注意：
- 构造函数不能是虚函数
- 基类析构函数最好是虚函数
- 尽量不要使用多继承
new和delete
C++内存申请和释放会使用new和delete关键字，而基本不会使用C语言中的malloc和free，可看下面的示例代码：
// new_delete.cc
#include 注意：
- new和delete要配对使用
- new[]和delete[]要配对使用
- maloc和free要配对使用
-
类型转换：既然使用了C++语言，在类型转换方面就一定要使用C++风格，这比C语言风格的强制类型转换更安全。
- static_cast
float f = 1.0f;int a = static_cast(f); - const_cast
const char* cc = "hello world\n";char* c = const_cast- dynamic_cast
struct Base {};struct Derive : public Base {};void func() { Base* base = new Derive; Derive* derive = dynamic_cast- reinterpret_cast
A *a = new A;void* d = reinterpret_cast
C++11常用新特性
C++的重大变革肯定是C++11啦，C++11标准引入了很多有用的新特性，这仿佛打开了新世界的大门，让C++开发者开发效率大幅提高，下面我会列出C++11常用的新特性，并附上简单的实例代码：
auto & decltype：用于类型推导
auto用于推导变量类型，decltype用于推导表达式返回值类型
// auto_decltype.cc
int main() {
auto a = 10; // 10是int型，可以自动推导出a是int
int x = 0;
decltype(x) y; // y是int类型
decltype(x + y) z; // z是int类型
return 0;
}
std::function：用于封装一个函数，功能类似于函数指针，但却比函数指针方便的多。
// function.cc
#include lambda表达式：随时可方便定义的一个匿名函数。
// lambda.cc
#include **注意：**lambda表达式的变量捕获方式分为值捕获和引用捕获
int a = 0;
auto f1 = [=](){ return a; }; // 值捕获a
cout << f1() << endl;
auto f2 = [=]() { return a++; }; // 修改按值捕获的外部变量，error
auto f3 = [=]() mutable { return a++; };
std::function和std::bind使得我们平时编程过程中封装函数更加的方便，而lambda表达式将这种方便发挥到了极致，可以在需要的时间就地定义匿名函数，不再需要定义类或者函数等，在自定义STL规则时候也非常方便，让代码更简洁，更灵活，开发效率也更高。
std::thread：C++11中使用std::thread创建线程，使用非常的方便，直接看代码：
void func() { std::cout << "new thread \n"; }
int main() {
std::thread t(func);
if (t.joinable()) {
t.join(); // 或者t.detach();
}
return 0;
}
```
**注意：**使用std::thread一定要记得join或者detach。
#### RAII：既然使用C++，那一定要理解RAII风格（利用对象生命周期管理资源），继续往下看：如果不使用RAII风格，加锁解锁我们怎么办？
```c++
// 不使用RAII
void func() {
std::mutex mutex;
mutex.lock();
if (xxx) {
mutex.unlock();
return;
}
if (xxxx) {
mutex.unlock();
return;
}
...
mutex.unlock();
}
```
而如果使用RAII呢：
```c++
void func() {
std::unique_lock<std::mutex> lock(mutex);
if (xxx) return;
if (xxxx) return;
...
}
```
是不是方便了很多，这里介绍了std::unique_lock的使用，还有一种锁是std::lock_guard，使用方式相同，至于它们之间有什么区别，我这里卖个关子，大家可以自行查找哈，锻炼一下自己的搜索能力。
智能指针也是典型的RAII风格，如果不使用智能指针管理内存是这样：
```c++
void func() {
A* a = new A;
if (xxx) {
delete a;
return;
}
if (xxxx) {
delete a;
return;
}
...
delete a;
}
```
而如果使用智能指针是这样：
```c++
void func() {
std::shared_ptr<A> sp = std::make_shared<A>(); // unique_ptr类似
std::shared_ptr<A> sp = std::shared_ptr<A>(new A); // 尽可能使用make_shared或者make_unique(C++14)
if (xxx) return;
if (xxxx) return;
...
}
又方便了很多吧，unique_ptr和shared_ptr的区别本文也不介绍，文章最后我会列出学习资料，在学习资料里可以找到答案。
原子操作：使用std::atomic可达到原子效果，使用方法：
std::atomic<int> ai;
ai++;
ai.store(100);
int a = ai.load();
enum class：带有作用域的枚举类型，可用于完全替代enum，为什么要使用enum class呢？我们先看一段直接使用enum的代码：
enum AColor {
kRed,
kGreen,
kBlue
};
enum BColor {
kWhite,
kBlack,
kYellow
};
int main() {
if (kRed == kWhite) {
cout << "red == white" << endl;
}
return 0;
}
不带作用域的枚举类型可以自动转换成整形，且不同的枚举可以相互比较，代码中的kRed居然可以和kWhite比较，这都是潜在的难以调试的bug，而这种完全可以通过有作用域的枚举来规避。所以出现了enum class：
enum class AColor {
kRed,
kGreen,
kBlue
};
enum class BColor {
kWhite,
kBlack,
kYellow
};
int main() {
if (AColor::kRed == BColor::kWhite) { // 编译失败
cout << "red == white" << endl;
}
return 0;
}
使用enum class可以在编译层面就规避掉一些难以调试的bug，使代码健壮性更高。
condition_variable：条件变量
std::condition_variable cv;
std::mutex mutex_;
void func1() {
std::unique_lock<std::mutex> lock(mutex_);
--count;
if (count == 0) cv.notify_all();
}
void func2() {
std::unique_lock<std::mutex> lock(mutex_);
while (count) {
cv.wait(lock);
}
}
**注意：**不要直接用wait，而要记得使用wait(mutex, cond)或者while(cond) {wait(mutex);}
nullptr：表示空指针可以使用nullptr，不要使用NULL
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;
}
chrono：时间相关函数可以考虑使用chrono库，例如休眠某个时间段：
void customSleep() {
std::this_thread::sleep_for(std::chrono::milliseconds(5));
std::this_thread::sleep_for(std::chrono::seconds(5));
}
使用chrono可以精确的指定时间单位，可以明确的之道休眠的是几毫秒还是几秒，非常方便。
chrono中包含三种时钟：
- steady_clock：单调时钟，只会增加，常用语记录程序耗时
- system_clock：系统时钟，会随系统时间改动而变化
- high_resolution_clock：当前系统最高精度的时钟，通常就是steady_clock
拿计时举例：
void customSleep() {
std::this_thread::sleep_for(std::chrono::milliseconds(5));
std::this_thread::sleep_for(std::chrono::seconds(5));
}
int main() {
std::chrono::time_point begin = std::chrono::high_resolution_clock::now();
customSleep();
auto end = std::chrono::high_resolution_clock::now();
auto diff = end - begin;
long long diffCount = std::chrono::duration_cast(diff).count();
cout << diffCount << "\n";
return 0;
}
STL
使用C++有几个能不用STL标准库的，这里列出了常用的STL，并贴出使用代码。
std::vector：可以理解为动态可自动扩容的数组，使用vector需要掌握几个常用函数的使用
- resize
- reserve
- capacity
- clear
- swap
- at
void func() {
std::vector<int> vec;
std::cout << "vector size " << vec.size() << "\n"; // vector size 0
std::cout << "vector capacity " << vec.capacity() << "\n"; // vector capacity 0
vec.push_back(1);
vec.emplace_back(2);
vec.push_back(3);
std::cout << "====================== \n";
std::cout << "vector size " << vec.size() << "\n"; // vector size 3
std::cout << "vector capacity " << vec.capacity() << "\n"; // vector capacity 4
vec.reserve(200);
std::cout << "====================== \n";
std::cout << "vector size " << vec.size() << "\n"; // vector size 3
std::cout << "vector capacity " << vec.capacity() << "\n"; // vector capacity 200
vec.resize(20);
std::cout << "====================== \n";
std::cout << "vector size " << vec.size() << "\n"; // vector size 20
std::cout << "vector capacity " << vec.capacity() << "\n"; // vector capacity 200
vec.clear();
std::cout << "====================== \n";
std::cout << "vector size " << vec.size() << "\n"; // vector size 0
std::cout << "vector capacity " << vec.capacity() << "\n"; // vector capacity 200
std::vector<int>().swap(vec);
std::cout << "====================== \n";
std::cout << "vector size " << vec.size() << "\n"; // vector size 0
std::cout << "vector capacity " << vec.capacity() << "\n"; // vector capacity 0
}
**注意：**for循环中erase某一个节点时要处理好迭代器的指向问题
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);
}
}
}
remove函数不会真正的删除某个元素，它只会把某个要删除的元素移动到容器尾部，真正要删除还需使用erase，需要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);
}
std::array：开发时可以考虑用std::array代替普通数组，因为它有获取长度，遍历，边界检查等功能
int main() {
std::array<int, 10> array;
// int array[10];
array.at(10) = 20; // terminating with uncaught exception of type std::out_of_range: array::at
std::cout << "hello " << array.at(10) << "\n";
return 0;
}
std::map & std::unordered_map：都是key-value级别的字典，使用方式相同，一个使用树实现，一个使用哈希表实现，可根据需求选择具体使用哪种字典。
int main() {
std::map<int, std::string> map;
map[1] = std::string("hello");
std::cout << map[1] << "\n";
return 0;
}
std::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 << "\n";
return 0;
}
**注意：**list的排序需要使用list.sort()，不能使用std::sort
std::tuple：我个人经常使用，tuple像结构体一样，也可以理解为pair的延伸
struct T {
int a_;
int b_;
int c_;
T(int a, int b, int c) : a_(a), b_(b), c_(c) {}
};
int main() {
T a(1, 2, 3);
std::cout << "a " << a.a_ << " b " << a.b_ << " c " << a.c_ << "\n";
std::tuple<int, int, int> tuple = std::make_tuple(2, 3, 4);
std::cout << "a " << std::get<0>(tuple) << " b " << std::get<1>(tuple) << " c " << std::get<2>(tuple) << "\n";
return 0;
}