1. 知道坑在哪儿，不要掉坑（Effective C++系列）
2. How to make your life easier，怎么写更清楚明白省事 （还是Effective C++系列）
3. 你写下的code大致会被编译器怎么处理，以防止遇到奇怪的编译错误或者诡异的bug时懵逼（C++ Primer系列）
4. 学会使用STL，有助于偷懒（《C++标准程序库》，加书名号表示这也是一本书！）
5. 了解一些优秀的工程实践，这样写代码时候有个导航，少走弯路，错路（比如好好看看
   陈硕
   那本Linux多线程编程实践）

C编译器编译代码生成的obj文件的符号表内，函数名称保持原样，比如int add(int,int)函数在符号表内就叫做add；C++编译器编译C++代码生成的obj文件符号表内，因为有overload的存在，函数名称的符号不再是原来的比如add，而是类似_Z3addii这样的（这是我的g++结果）。

那么，一个C程序需要使用某个C++库内的add函数时，C程序这边期望的是add，但C++库内是_Z3addii这样的，不匹配嘛对不对，所以链接阶段要报错，说找不到add这个函数。

同样，一个C++程序需要使用某个C库内的add函数，C++程序这边期望的是_Z3addii，但C库内是add这样的，同样不匹配，链接阶段也是报错，这次是说找不到_Z3addii。

extern "C"的意思，是让C++编译器（不是C编译器，而且是编译阶段，不是链接阶段）在编译C++代码时，为被extern “C”所修饰的函数在符号表中按C语言方式产生符号名（比如前面的add），而不是按C++那样的增加了参数类型和数目信息的名称（_Z3addii）。

展开来细说，就是：

如果是C调用C++函数，在C++一侧对函数声明加了extern "C"后符号表内就是add这样的名称，C程序就能正常找到add来调用；如果是C++调用C函数，在C++一侧在声明这个外部函数时，加上extern "C"后，C++产生的obj文件符号表内就也是标记为它需要一个名为add的外部函数，这样配合C库，就一切都好。

总结：

不管是C代码调用C++编译器生成的库函数，还是C++代码调用C编译器生成的库函数，都需要在C++代码一侧对相应的函数进行extern “C”申明。

C/C++多线程编程中不要使用volatile。
（注：这里的意思指的是指望volatile解决多线程竞争问题是有很大风险的，除非所用的环境系统不可靠才会为了保险加上volatile，或者是从极限效率考虑来实现很底层的接口。这要求编写者对程序逻辑走向很清楚才行，不然就会出错）
C++11标准中明确指出解决多线程的数据竞争问题应该使用原子操作或者互斥锁。
C和C++中的volatile并不是用来解决多线程竞争问题的，而是用来修饰一些因为程序不可控因素导致变化的变量，比如访问底层硬件设备的变量，以提醒编译器不要对该变量的访问擅自进行优化。

多线程场景下可以参考《Programming with POSIX threads》的作者Dave Butenhof对
Why don't I need to declare shared variables VOLATILE?
这个问题的解释：
comp.programming.threads FAQ

首先需要明确的是，程序在运行起来，内存访问的顺序和程序员编写的顺序不一定一致，基于这个前提下，Memory barrier 就有存在的必要了。看一个例子：

x = r;
y = 1;

这里，y = 1 在实际运行中可能先于 x = r 进行。实际上，在单线程环境中，这两句谁先执行谁后执行都没有任何关系，它们之间不存在依赖关系，但是如果在多线程中 x 和 y 的赋值存在隐式依赖时：

// thread 1
while (!x);
// memory barrier
assert(y == r);

// thread 2
y = r;
// memory barrier
x = 1;

此代码断言就可能失败。

Memory barrier 能够保证其之前的内存访问操作先于其后的完成。如果说到 Memory barrier 常用的地方，那么包括：

1. 实现锁机制
2. 用于驱动程序
3. 编写无锁的代码

这里篇幅有限，如果你作为程序员，你可以从 /scalability/paper/whymb.2010.06.07c.pdf

我个人也对 Memory barrier 做了一点小研究，主要写了几个例子验证乱序的存在： e/s/2OVFCP1_wkXs20LtbT1nXNrj0EqwFC1zZAjT2bCeRi3Tzco2

3. dynamic cast

reinterpret_cast运算符是用来处理无关类型之间的转换；它会产生一个新的值，这个值会有与原始参数（expressoin）有完全相同的比特位。

reinterpret_cast用在任意指针（或引用）类型之间的转换；以及指针与足够大的整数类型之间的转换；从整数类型（包括枚举类型）到指针类型，无视大小。

用来辅助哈希函数。下边是MSNDN上的例子：

                // expre_reinterpret_cast_Operator.cpp
// compile with: /EHsc
#include <iostream>
// Returns a hash code based on an address
unsigned short Hash( void *p ) {
	unsigned int val = reinterpret_cast<unsigned int>( p );
	return ( unsigned short )( val ^ (val >> 16));
}

using namespace std;
int main() {
	int a[20];
	for ( int i = 0; i < 20; i++ )
		cout << Hash( a + i ) << endl;
}

C++中的类型转换分为两种：

1.隐式类型转换；
2.显式类型转换。

而对于隐式变换，就是标准的转换，在很多时候，不经意间就发生了，比如int类型和float类型相加时，int类型就会被隐式的转换位float类型，然后再进行相加运算。而关于隐式转换不是今天总结的重点，重点是显式转换。在标准C++中有四个类型转换符：static_cast、dynamic_cast、const_cast和reinterpret_cast；下面将对它们一一的进行总结。

static_cast

static_cast的转换格式：static_cast <type-id> (expression)

将expression转换为type-id类型，主要用于非多态类型之间的转换，不提供运行时的检查来确保转换的安全性。主要在以下几种场合中使用：

1.用于类层次结构中，基类和子类之间指针和引用的转换；
当进行上行转换，也就是把子类的指针或引用转换成父类表示，这种转换是安全的；
当进行下行转换，也就是把父类的指针或引用转换成子类表示，这种转换是不安全的，也需要程序员来保证；

2.用于基本数据类型之间的转换，如把int转换成char，把int转换成enum等等，这种转换的安全性需要程序员来保证；

3.把void指针转换成目标类型的指针，是及其不安全的；

注：static_cast不能转换掉expression的const、volatile和__unaligned属性。

dynamic_cast

dynamic_cast的转换格式：dynamic_cast <type-id> (expression)

将expression转换为type-id类型，type-id必须是类的指针、类的引用或者是void *；如果type-id是指针类型，那么expression也必须是一个指针；如果type-id是一个引用，那么expression也必须是一个引用。

在C++的面对对象思想中，虚函数起到了很关键的作用，当一个类中拥有至少一个虚函数，那么编译器就会构建出一个虚函数表(virtual method table)来指示这些函数的地址，假如继承该类的子类定义并实现了一个同名并具有同样函数签名（function siguature）的方法重写了基类中的方法，那么虚函数表会将该函数指向新的地址。此时多态性就体现出来了：当我们将基类的指针或引用指向子类的对象的时候，调用方法时，就会顺着虚函数表找到对应子类的方法而非基类的方法。

当然虚函数表的存在对于效率上会有一定的影响，首先构建虚函数表需要时间，根据虚函数表寻到到函数也需要时间。

因为这个原因如果没有继承的需要，一般不必在类中定义虚函数。但是对于继承来说，虚函数就变得很重要了，这不仅仅是实现多态性的一个重要标志，同时也是dynamic_cast转换能够进行的前提条件。

假如去掉上个例子中Stranger类析构函数前的virtual，那么语句
Children* child_r = dynamic_cast<Children*> (stranger_r);

在编译期就会直接报出错误，具体原因不是很清楚，我猜测可能是因为当类没有虚函数表的时候，dynamic_cast就不能用RTTI来确定类的具体类型，于是就直接不通过编译。

对于从子类到基类的指针转换，static_cast和dynamic_cast都是成功并且正确的（所谓成功是说转换没有编译错误或者运行异常；所谓正确是指方法的调用和数据的访问输出是期望的结果），这是面向对象多态性的完美体现。

而从基类到子类的转换，static_cast和dynamic_cast都是成功的，但是正确性方面，我对两者的结果都先进行了是否非空的判别：dynamic_cast的结果显示是空指针，而static_cast则是非空指针。但很显然，static_cast的结果应该算是错误的，子类指针实际所指的是基类的对象，而基类对象并不具有子类的Study()方法(除非妈妈又想去接受个"继续教育")。

对于没有关系的两个类之间的转换，输出结果表明，dynamic_cast依然是返回一个空指针以表示转换是不成立的；static_cast直接在编译期就拒绝了这种转换。

4、malloc/ new 

new的功能是在堆区新建一个对象，并返回该对象的指针。

所谓的【新建对象】的意思就是，将调用该类的构造函数，因为如果不构造的话，就不能称之为一个对象。

而malloc只是机械的分配一块内存，如果用mallco在堆区创建一个对象的话，是不会调用构造函数的

6、stl

class Base
{
    public:
    
    Base(int i) :baseI(i){};
    
    int getI(){ return baseI; }
    
    static void countI(){};
    
    virtual void print(void){ cout << "Base::print()"; }
    
    virtual ~Base(){}
    
    private:
    
    int baseI;
    
    static int baseS;
};

8、shared_ptr

When using unique_ptr, there can be at most one unique_ptr pointing at any one resource. When that unique_ptr is destroyed, the resource is automatically reclaimed. Because there can only be one unique_ptr to any resource, any attempt to make a copy of a unique_ptr will cause a compile-time error. For example, this code is illegal:

unique_ptr<T> myPtr(new T);       // Okay
unique_ptr<T> myOtherPtr = myPtr; // Error: Can't copy unique_ptr

However, unique_ptr can be moved using the new move semantics:

unique_ptr<T> myPtr(new T);                  // Okay
unique_ptr<T> myOtherPtr = std::move(myPtr); // Okay, resource now stored in myOtherPtr

Similarly, you can do something like this:

unique_ptr<T> MyFunction() {
    unique_ptr<T> myPtr(/* ... */);

    /* ... */

    return myPtr;
}

This idiom means "I'm returning a managed resource to you. If you don't explicitly capture the return value, then the resource will be cleaned up. If you do, then you now have exclusive ownership of that resource." In this way, you can think of unique_ptr as a safer, better replacement for auto_ptr.

shared_ptr, on the other hand, allows for multiple pointers to point at a given resource. When the very last shared_ptr to a resource is destroyed, the resource will be deallocated. For example, this code is perfectly legal:

shared_ptr<T> myPtr(new T);       // Okay
shared_ptr<T> myOtherPtr = myPtr; // Sure!  Now have two pointers to the resource.

Internally, shared_ptr uses reference counting to track how many pointers refer to a resource, so you need to be careful not to introduce any reference cycles.

In short:

1. Use unique_ptr when you want a single pointer to an object that will be reclaimed when that single pointer is destroyed.
2. Use shared_ptr when you want multiple pointers to the same resource.

unique_ptr

unique_ptr 这个类的关键点在于这个定义：

unique_ptr(const unique_ptr&) = delete;

它把拷贝构造函数干掉了，这样的话，就不能直接这样用了：

  unique_ptr<A> pa(new A());
    unique_ptr<A> pb = pa;

这样也挺好，既然auto_ptr是因为多个变量持有同一个指针引起的，那么我尽量避免这种拷贝就好了。

唉，但这是C++啊，不留点口子肯定不是C++的风格，所以unique_ptr还留下了move赋值这种东西，这个我们不去看了。只知道有这么一回事就行了。我们今天的重点是shared_ptr

shared_ptr

shared_ptr也是对auto_ptr的一种改进，它的思路是，使用引用计数来管理指针。如果一个指针被多次使用了，那么引用计数就加一，如果减少一次使用，引用计数就减一。当引用计数变为0，那就可以真正地删除指针了。先看一下基本用法：

#include <iostream>
#include <memory>
using namespace std;

class A { 
private:
    int a;
public:
    A() {
        cout << "create object of A" << endl;
        a = 1;
    }   

    ~A() {
        cout << "destroy an object A" << endl;
    }   

    void print() {
        cout << "a is " << a << endl;
    }   
};

int main() {
    shared_ptr<A> pa(new A());
    shared_ptr<A> pb = pa;
    return 0;
}

大家可以与上节课的auto_ptr比较一下，就发现它们的区别了，当然了，这样写还是不行：

int main() {
    A * a = new A();
    shared_ptr<A> pa(a);
    shared_ptr<A> pb(a);
    return 0;
}

这种写法还是会让指针被 delete 两次。

它的基本原理是