C++基础知识归纳(2)-进阶篇

正确释放vector的内存(clear(), swap(), shrink_to_fit())

#include
#include
using namespace std;
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);

    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;

    v.clear();
    cout << "after clear size:" << v.size() << endl;
    cout << "after clear capacity:" << v.capacity() << endl;
    return 0;
}
//输出
size:5
capacity:6
after clear size:0
after clear capacity:6

详细请查阅：实战c++中的vector系列–正确释放vector的内存(clear(), swap(), shrink_to_fit())

STL迭代器删除元素注意

【C++ STL】Set和Multiset

自动排序的主要优点在于使二叉树搜寻元素具有良好的性能，在其搜索函数算法具有对数复杂度。但是自动排序也造成了一个限制，不能直接改变元素值，因为这样会打乱原有的顺序，要改变元素的值，必须先删除旧元素，再插入新元素。所以sets和multisets具有以下特点：

• 不提供直接用来存取元素的任何操作元素
• 通过迭代器进行元素的存取。

详细参考：Set和Multiset

C++中使用vector建立最大堆和最小堆

C++中使用vector建立最大堆和最小堆

• 为什么pop_heap()的用法要反过来呢？

要从我们的目的来考虑，使用pop_heap()的绝大部分目的是要把堆顶元素pop出堆中，因为它最大或最小。如果先用vector的pop_back()，它删除的不是堆顶元素（nums[0]），而是vector的最后一个元素。可见这不是我们想要的结果：对于最大堆，最后一个元素既不是最大，也不一定是最小；对于最小堆，最后一个元素既不是最小，也不一定是最大。pop出来没有意义。

• 观察pop_heap()对堆做了什么？

pop_heap()把堆顶元素放到了最后一位，然后对它前面的数字重建了堆。这样一来只要再使用pop_back()把最后一位元素删除，就得到了新的堆

C++ multiset通过greater、less指定排序方式，实现最大堆、最小堆功能

STL中的set和multiset基于红黑树实现，默认排序为从小到大。
定义三个multiset实例，进行测试：

multiset<int, greater<int>> greadterSet;
    multiset<int, less<int>> lessSet;
    multiset<int> defaultSet;

    for (int i = 0; i < 10; i++) {
        int v = int(arc4random_uniform(10));
        greadterSet.insert(v);
        lessSet.insert(v);
        defaultSet.insert(v);
    }

    for (auto v: greadterSet) {
        printf("%d ", v);
    }
    printf("\n");
    for (auto v: lessSet) {
        printf("%d ", v);
    }
    printf("\n");
    for (auto v: defaultSet) {
        printf("%d ", v);
    }
    printf("\n");
/*
输出结果：
9 9 8 7 7 5 4 1 0 0 
0 0 1 4 5 7 7 8 9 9 
0 0 1 4 5 7 7 8 9 9 
*/

可以为multiset指定排序方式，以此实现类似最大堆、最小堆的功能。

比如：当前排序方式为降序，那么greaterSet.begin()所指向的值就是最大值。

可以参考《剑指Offer》中的 面试题30:最小的K个数。

详细请查看：C++ multiset通过greater、less指定排序方式，实现最大堆、最小堆功能

C++11 lambda表达式

详细请参考：lamda表达式详解1 / lamda表达式详解2

std::bind

bind是对C++98标准中函数适配器bind1st/bind2nd的泛化和增强，可以适配任意的可调用对象，包括函数指针、函数引用、成员函数指针和函数对象。

bind接受的第一个参数必须是一个可调用的对象f,可以是函数、函数指针、函数对象和成员函数指针，之后接受的参数的数量必须与f的参数数量相等，这些参数将被传递给f作为入参。

绑定完成后，bind会返回一个函数对象，它内部保存了f的拷贝，具有operator(),返回值类型被自动推导为f的返回值类型。反生调用时，这个函数对象将把之前存储的参数转发给f完成调用。

详细请参阅：std::bind 的使用说明

C++ vector的reserve和resize详解

vector 的reserve增加了vector的capacity，但是它的size没有改变！而resize改变了vector的capacity同时也增加了它的size!

• 原因如下：reserve是容器预留空间，但在空间内不真正创建元素对象，所以在没有添加新的对象之前，不能引用容器内的元素。加入新的元素时，要调用push_back()/insert()函数。
• resize是改变容器的大小，且在创建对象，因此，调用这个函数之后，就可以引用容器内的对象了，因此当加入新的元素时，用operator[]操作符，或者用迭代器来引用元素对象。此时再调用push_back()函数，是加在这个新的空间后面的。

两个函数的参数形式也有区别的，reserve函数之后一个参数，即需要预留的容器的空间；resize函数可以有两个参数，第一个参数是容器新的大小， 第二个参数是要加入容器中的新元素，如果这个参数被省略，那么就调用元素对象的默认构造函数。

下面是这两个函数使用例子：

vector<int> myVec;
myVec.reserve( 100 );     // 新元素还没有构造, 
                                       // 此时不能用[]访问元素
for (int i = 0; i < 100; i++ )
{ 
     myVec.push_back( i ); //新元素这时才构造
}
myVec.resize( 102 );      // 用元素的默认构造函数构造了两个新的元素
myVec[100] = 1;           //直接操作新元素
myVec[101] = 2;  

C++ 清空队列(queue)的几种方法

C++中的queue自身是不支持clear操作的，但是双端队列deque是支持clear操作的。

方法一:直接用空的队列对象赋值

queue<int> q1;
// process
// ...
q1 = queue<int>();

方法二:遍历出队列

while (!Q.empty()) Q.pop();

方法三:使用swap，这种是最高效的，定义clear，保持STL容器的标准。

void clear(queue<int>& q) {
	queue<int> empty;
	swap(empty, q);
}

c++优先队列(priority_queue)用法详解

c++优先队列

怎么在一块指定的内存下调用构造函数

使用placement new就不用开辟新内存了

class A;
char* p=new char(sizeof(A));
A* q=new(p) A;
//或
int a[10];
int *p = new(a) int;

vector中emplace_back方法的用途

使用push_back插入元素的办法：

vector<stu_info> v;
v.push_back(stu_info("nginx"));

在push_back之前，必须使用stu_info实例一个临时对象传入才行，实例对象就必须要执行构造函数，然后拷贝到容器中再执行一次拷贝构造函数。
而emplace_back可以不用执行多余的拷贝构造函数了，它是直接在容器内执行对象的构造：

vector<stu_info> v;
v.emplace_back("redis");

两个函数的执行结果：

emplace相关函数可以减少内存拷贝和移动。当插入rvalue，它节约了一次move构造，当插入lvalue，它节约了一次copy构造。

详细请参阅 : emplace_back() 和 push_back 的区别 / C++11使用emplace_back代替push_back

C++设计模式

C++ 常用设计模式（学习笔记）

Malloc是线程安全但不可重入的

我们知道一个函数要做到线程安全，需要解决多个线程调用函数时访问共享资源的冲突。而一个函数要做到可重入，需要不在函数内部使用静态或全局数据，不返回静态或全局数据，也不调用不可重入函数。

malloc函数线程安全但是不可重入的，因为malloc函数在用户空间要自己管理各进程共享的内存链表，由于有共享资源访问，本身会造成线程不安全。为了做到线程安全，需要加锁进行保护。同时这个锁必须是递归锁，因为如果当程序调用malloc函数时收到信号，在信号处理函数里再调用malloc函数，如果使用一般的锁就会造成死锁（信号处理函数中断了原程序的执行），所以要使用递归锁。

虽然使用递归锁能够保证malloc函数的线程安全性，但是不能保证它的可重入性。按上面的场景，程序调用malloc函数时收到信号，在信号处理函数里再调用malloc函数就可能破坏共享的内存链表等资源，因而是不可重入的。

至于malloc函数访问内核的共享数据结构可以正常的加锁保护，因为一个进程程调用malloc函数进入内核时，必须等到返回用户空间前夕才能执行信号处理函数，这时内核数据结构已经访问完成，内核锁已释放，所以不会有问题。

可重入函数也可以这样理解，重入即表示重复进入，首先它意味着这个函数可以被中断，其次意味着它除了使用自己栈上的变量以外不依赖于任何环境（包括static），这样的函数就是purecode（纯代码）可重入，可以允许有多个该函数的副本在运行，由于它们使用的是分离的栈，所以不会互相干扰。

关键字noexcept

从C++11开始，我们能看到很多代码当中都有关键字noexcept。比如下面就是std::initializer_list的默认构造函数，其中使用了noexcept。

      constexpr initializer_list() noexcept
      : _M_array(0), _M_len(0) { }

该关键字告诉编译器，函数中不会发生异常, 这有利于编译器对程序做更多的优化。
如果在运行时，noexecpt函数向外抛出了异常（如果函数内部捕捉了异常并完成处理，这种情况不算抛出异常），程序会直接终止，调用std::terminate()函数，该函数内部会调用std::abort()终止程序。

位操作

位操作（Bit Manipulation）可以玩出很多奇技淫巧，但是这些技巧大部分都过于晦涩，没必要深究，读者只要记住一些有用的操作即可。

几个有趣的位操作

1. 利用或操作 | 和空格将英文字符转换为小写

('a' | ' ') = 'a'
('A' | ' ') = 'a'

2. 利用与操作 & 和下划线将英文字符转换为大写

('b' & '_') = 'B'
('B' & '_') = 'B'

4. 利用异或操作 ^ 和空格进行英文字符大小写互换

('d' ^ ' ') = 'D'
('D' ^ ' ') = 'd'

以上操作能够产生奇特效果的原因在于 ASCII 编码。字符其实就是数字，恰巧这些字符对应的数字通过位运算就能得到正确的结果，有兴趣的读者可以查 ASCII 码表自己算算，本文就不展开讲了。

5. 判断两个数是否异号

int x = -1, y = 2;
bool f = ((x ^ y) < 0); // true

int x = 3, y = 2;
bool f = ((x ^ y) < 0); // false

这个技巧还是很实用的，利用的是补码编码的符号位。如果不用位运算来判断是否异号，需要使用 if else 分支，还挺麻烦的。读者可能想利用乘积或者商来判断两个数是否异号，但是这种处理方式可能造成溢出，从而出现错误。（关于补码编码和溢出，参见前文）

算法常用操作 n&(n-1)

这个操作是算法中常见的，作用是消除数字 n 的二进制表示中的最后一个 1。

比如判断一个数是不是 2 的指数：一个数如果是 2 的指数，那么它的二进制表示一定只含有一个 1：

2^0 = 1 = 0b0001
2^1 = 2 = 0b0010
2^2 = 4 = 0b0100

如果使用位运算技巧就很简单了（注意运算符优先级，括号不可以省略）：

bool isPowerOfTwo(int n) {
    if (n <= 0) return false;
    return (n & (n - 1)) == 0;
}

零拷贝

详细请参阅： 什么是 “零拷贝” ？

静态库和动态库比较

1. 静态库
   将静态库的内容添加到程序中区，此时程序的空间，变成了源程序空间大小+静态库空间大小。
2. 动态库（共享库）
   常驻内存，当程序需要调用相关函数时，会从内存调用。
3. 区别
   静态库：对空间要求较低，而时间要求较高的核心程序中。
   动态库：对时间要求较低，对空间要求较高。

位域

详细请参阅：C/C++位域知识小结

c++ new操作符的重载

详细请参阅：

关于c++ new操作符的重载 / C++ new 解析重载

C++的function

发挥函数指针的作用，以及生成函数对象。
function是一个包装类，它可以接收普通函数、函数类对象(也就是实现了（）操作符的类对象）等

详细请参阅：深入浅出C++的function

写个函数在main函数执行前先运行

1. 全局static变量的初始化在程序初始阶段，先于main函数的执行，所以可以利用这一点。在leetcode里经常见到利用一点，在main之前关闭cin与stdin的同步来“加快”速度的黑科技：

static int _ = []{
    cin.sync_with_stdio(false);
    return 0;
}();

__attribute((constructor))是gcc扩展，标记这个函数应当在main函数之前执行。同样有一个__attribute((destructor))，标记函数应当在程序结束之前（main结束之后，或者调用了exit后）执行

2. __attribute((constructor))是gcc扩展，标记这个函数应当在main函数之前执行。同样有一个__attribute((destructor))，标记函数应当在程序结束之前（main结束之后，或者调用了exit后）执行;
   test1:
   全局(static)变量的初始化在程序初始阶段，先于main函数的执行;

#include  
using namespace std;
 
__attribute((constructor))void test0()
{
    printf("before main 0\n");
}
 
int test1(){
    cout << "before main 1" << endl;
    return 54;
}
  
static int i = test1();
  
int main(int argc, char** argv) {
  
    cout << "main function." <<endl;
    return 0;
}