C++盲点

const

const指针

1 char greeting[] ="hello";
2 char* p = greeting; // non-const pointer, non-const data
3 const char* p = greeting; // non-const pointer, const data
4 char* const p = greeting; // const pointer, non-const data
5 const char* const p = greeting; //const pointer, const data

1 void f1(const Object* o);
2 void f2(Object const* o); 

这两个是一样的；

const vector<int>::iterator更像是T* const;

vector<int>::const_iterator更像是const T*;

enum不能取地址，const可以取地址，define没有任何约束；

const函数是为了可以操作const对象；

 1 class Test {
 2 public:
 3     void print() const {}
 4     void mut() const { m1 = 1; }
 5 private:
 6     mutable int m1; // can be changed even in const functions
 7 };
 8 const Test t;
 9 t.print();
10 t. mut(); //legal

const版本和非const版本的代码重用。实现const函数，在non-const函数中调用const版本。

1 class Test {
2 public:
3    const int& operator[](int i) const {...}
4     int& operator[](int i) {
5         const_cast<int&>(static_cast<const Test&>(*this)[i]);
6     }
7 }; 

singleton的初始化实现

local static 能够确保在调用时已经初始化。但是仍然不能确保线程安全。所有non-const的static对象，无论它是local还是non-local，在多线程环境下都会有问题。解决的方法就是在一开始的单线程环境下，手动调用这些函数实现初始化。这样可以避免与初始化有关的race conditions。

1 class Test {
2 public:
3    Test& test() {
4         static Test t;
5         return t;
6     }
7 };    

virtual

多态的析构函数，设成virtual，这样在delete的时候才会释放子类的所有资源。

1 class Parent {
2 public:
3     virtual ~Parent() {...}
4 };
5 class Child1: public Parent {};
6 Parent* p = new Child1;
7 delete p;

多态的析构函数必须是virtual。

在析构函数里，尽量不要调用会发生异常的操作。如果有，也要提供额外的接口，让用户有机会自己调用处理。

不要在构造函数或析构函数里调用virtual 函数。此时调用virtual函数，调用的是base类的版本。

线程安全；