0. Google C++编程规范
：http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml
：http://zh-google-styleguide.readthedocs.org/en/latest/google-cpp-styleguide/contents/
1.
2. Effective C++学习笔记
(1)
(2)
(3)
(4)
(5)
(6)
3. Effective STL学习笔记
(1)
(2)
(3)
(4)
(5)
(6) 函数对象：
(7)
4. C++ std::string 代码实现
class Mystring { public: Mystring() : data_(new char[1]) { *data = '\0'; } Mystring(const char* str) : data_(new char[strlen(str) + 1]) { strcpy(data_, str); } Mystring(const Mystring& str) : data_(new char[str.size() + 1]) { strcpy(data_, str.c_str()); } ~Mystring() { delete[] data_; } // 重载赋值，采用copy and swap手法，旧式写法 Mystring& operator=(const Mystring& str) { Mystring tmp(str); swap(tmp); return *this; } // 重载赋值，采用copy and swap手法，新式写法 Mystring& operator=(Mystring& str) { swap(str); return *this; } int size() const { return (int)strlen(data_); } const char* c_str() const { return data_; } void swap(Mystring& str) { std::swap(data_, str.data_); } private: char* data_;};
5. C++ 智能指针 代码实现
智能指针类与普通指针一样，但它借由自动化内存管理保证了安全性，避免了诸如悬挂指针、内存泄露和分配失败等问题。
智能指针有好几种实现方式，STL和Boost库里都有实现，比如使用句柄类和引用计数方式。
我们现在使用引用计数定义智能指针，智能指针类将一个计数器与类指向的对象相关联。使用计数跟踪该类有多少个对象共享同一指针。
使用计数为0时，删除对象。使用计数有时也称为引用计数（reference count）。
使用一个计数变量，并将其置一，每新增一个对象的引用，该变量会加一，移除一个引用则减一，
即当对象作为另一对象的副本而创建时，复制构造函数复制指针并增加与之相应的使用计数的值。
当对一个对象进行赋值时（=操作符），覆写=操作符，这样才能将一个旧的智能指针覆值给另一指针，旧的引用计数减一，新的智能指针的引用计数则加一。
#include#include template class SmartPointer { public: SmartPointer (T* ptr) { ref = ptr; ref_count = (unsigned*)malloc(sizeof(unsigned)); *ref_count = 1; } SmartPointer (SmartPointer & sptr) { ref = sptr.ref; ref_count = sptr.ref_count; ++(*ref_count); } SmartPointer & operator=(SmartPointer & sptr) { if (this == &sptr) { return *this; } --(*ref_count); if (*ref_count == 0) { clear(); } ref = sptr.ref; ref_count = sptr.ref_count; ++(*ref_count); return *this; } ~SmartPointer () { --(*ref_count); if (*ref_count == 0) { clear(); } } T* GetValue() { return ref; } private: void clear() { delete ref; free(ref_count); ref = NULL; ref_count = NULL; } private: T* ref; unsigned* ref_count;};int main() { int* ip1 = new int(); *ip1 = 1111; int* ip2 = new int(); *ip2 = 2222; SmartPointer sp1(ip1); SmartPointer sp2(ip2); SmartPointer spa = sp1; sp2 = spa; return 0;}
6. POD、迭代器萃取、模板偏特化
POD(Plain Old Data)：标量类型 或 传统的C struct 类型，POD类型必然 拥有 默认的ctor、dtor、copy、assign
POD类类型就是指 class、struct、union，且不具有用户定义的构造函数、析构函数、拷贝算子、赋值算子；不具有继承关系，因此没有基类；不具有虚函数，所以就没有虚表；非静态数据成员没有私有或保护属性的、没有引用类型的、没有非POD类类型的（即嵌套类都必须是POD）、没有指针到成员类型的（因为这个类型内含了this指针）。
我们可以对 POD 型别采取最有效率的复制手法，而对 non-POD 型别采取最保险安全的作法
首先 利用迭代器萃取手法 萃取出迭代器 的 value type，然后判断该型别是否为 POD 型别
typedef typename __type_traits::is_POD_type is_POD;
迭代器所指对象的型别，称为该迭代器的 value type
“模板参数推导机制” 只能针对于 函数参数类型，不能推导 函数的返回值类型
不是所有的迭代器都是 class type，原声指针就不是!!!
STL(泛型思维)绝对必须接受原生指针作为一种迭代器，这个时候就需要针对特殊情况(原生指针)做特化处理，即模板偏特化
模板偏特化：在泛化设计中提供一个特化版本(将泛化版本中的某些template参数赋予特殊的指定)
迭代器traits手法本质上就是 模板偏特化，实质代码如下：
templatestruct iterator_traits { typedef typename T::value_type value_type;}
现在不管是class type 还是 原生指针int* , 我们都可以通过traits萃取出 迭代器的 value_type
7. C++ 单例模式 代码实现
8. C++ 实现不被继承的类
注：可以直接使用C++11的final关键字
9. c++ 虚函数 多态
多态两必要条件：(1) virtual函数 (2) 基类指针(引用)指向派生类对象
多态知识点：
(1) 任何含有 virtual函数的类及其派生类 均在类实例对象的首地址 安插一个指向虚函数表的指针(虚表指针，vptr)
为什么在 类对象的首地址(即this指针处) 存放 虚表指针呢？
Base* pBase = new Derived; // Base对象首地址、Derived对象首地址、this指针、虚表指针 均相同，非常方便的定位 虚表指针
(2) Derived类 会继承 Base类 的虚表，当Derived类 重定义了 Base类的某个函数，这时 Derived对应的虚函数表
Base::foo() ==> Derived::foo() // Derived::foo() 覆盖从基类 继承而来的 虚函数 Base::foo()
c++ this指针、虚函数
// c++中 所有non-static成员变量 和 virtual成员函数 都必须通过 this指针访问 class test { public: test(int value) : val(value) { } void foo1() { // 正确：non-virtual函数地址编译期确定，传入this指针，this指针为空，但是这个函数没有 访问 this空指针 fprintf(stdout, "hello world\n"); } void foo2() { // 错误：non-virtual函数地址编译期确定，传入this指针，this指针为空，但是这个函数 访问了 this空指针(因为 this->val) fprintf(stdout, "%d\n", val); } virtual void foo3() { // 错误：所有 virtual函数都需要通过 虚函数表确定，虚函数表需要 this指针来确定，因此 访问了 this空指针 fprintf(stdout, "hello world\n"); } static void foo4() { // 正确：所有static函数都没有this指针，所以不能访问 non-static成员变量 fprintf(stdout, "hello world\n"); } private: int val; }; test* pTest = NULL; // this指针为空 pTest->foo1(); pTest->foo2(); pTest->foo3(); pTest->foo4();
c/c++类型转换
class Base {};class Derived {};Base* pBase = new Derived; Base* pBase = new Derived[10]; /*1. 信息 = 比特位 + 解释方式，类型转换只是改变了 解释方式，数据未变2. 数组和结构体(struct、class)访问成员变量和成员函数 都是 首地址 + offset偏移type[i] ==> type(首地址) + i * sizeof(type)3. new Derived返回指向Derived类型的指针4. pBase = pDerived 指针的类型转换5. 一般情况下，sizeof(Base) 不等于 sizeof(Derived)6. 为什么第一句正确呢？ 因为 这一句 只分配了一个对象，并且 vptr位于对象首地址，因此 Base的首地址 == Derived的首地址 == this指针，故正确找到 vptr7. 为什么第二句一般情况下错误呢？通常情况下，sizeof(Base) 不等于 sizeof(Derived), 因此 pBase[i] 不等于 pDerived[i]，由于类型转换改变了解释方式，导致找不到Derived的正确this指针位置，因此vptr、析构函数就完全不正确了注：当 sizeof(Base) == sizeof(Derived) 时，可以正确运行，但这是一个未定义行为，所以禁止这样的写法*/
10. STL空间配置器
#ifndef _JJALLOC_#define _JJALLOC_#include// for placement new#include // for ptrdiff_t, size_t#include // for exit()#include // for UINT_MAX#include // for cerrnamespace JJ{ template inline T* _allocate(ptrdiff_t size, T*) { std::set_new_handler(0); T* tmp = (T*)(::operator new((size_t)(size * sizeof(T)))); if (tmp == 0) { std::cerr << "out of memory" << std::endl; exit(1); } return tmp; } template inline void _deallocate(T* buffer) { ::operator delete(buffer); } template inline void _construct(T1* p, const T2& value) { new(p) T1(value); } template inline void _destroy(T* ptr) { ptr->~T(); } // std::allocator的标准接口 template class allocator { public: typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef T& reference; typedef const T& const_reference; typedef size_t size_type; typedef ptrdiff_t difference_type; template struct rebind { typedef allocator other; }; pointer allocate(size_type n, const void* hint = 0) { return _allocate((difference_type)n, (pointer)0); } void deallocate(pointer p, size_type n) { _deallocate(p); } void construct(pointer p, const T& value) { _construct(p, value); } void destroy(pointer p) { _destroy(p); } pointer address(reference x) { return (pointer)&x; } const_pointer const_address(const_reference x) { return (const_pointer)&x; } size_type max_size() const { return size_type(UINT_MAX/sizeof(T)); } };}#endif // _JJALLOC_
使用配置器：
std::vector
