1. C++ Primer
2. Effective C++系列
3. 深度探索C++对象模型
4. STL源码剖析
5. C++ Templates

1. DirectX 引擎开发
2. Unreal C++编写
3. Leetcode 算法编程
4. Project 个人项目（如DependencyGraph）
5. 开源项目 / 写作业

1. 面向对象编程（OOP）
2. 模板与泛型编程（TGP）
3. 并发编程
4. C与STL
5. 函数式、元编程等

• B语言
• C语言 -> new C → C with Class → C++
• C++98/03
• C++11/14
• C++17/20

---

---

#ifndef __CLASSNAME_H__
#define __CLASSNAME_H__
...
#endif

• 如果是栈上创建的，那么它会作为local变量被回收，引用也就会变空。所以在栈上创建的对象不应该返回引用，而是直接返回该对象
• 如果是堆上则不会。因此，如果想要返回某对象的引用，该对象应该在堆上创建

int _tmain(int argc,_TCHAR* argv[]) {...}    // 为支持unicode
[tchar.h]中
#define _tmain main

ctor() = default;  // 要求编译器生成默认构造函数，并赋给我们定义的构造函数

A(int i,string n):id(i),name(n) {...}  // 初始值列表

A(): A(1, "") {...}  // 先调用其他构造函数来完成该构造的初始化

A(string n): A(1, n) {...} // 如我们定义了一个string转换构造函数
void Func(const A&) {...}  // 定义了一个函数要求传入A类型




string name="kira";   // 这时定义一个string类型
Func(name);           // name传入Func是合法的！string被隐式转换为了A类型




Func("kira");         // 但是，你不能直接传入字符串，因为const char[]到string也会经过一步类型转换，而编译器只允许一步类类型转换（不合法）

• 关键字explicit只对一个实参的构造函数有效
• 在类外部定义成员函数时不需要使用explicit关键字

A::operator string() { return name; }
A a("kira");
string name = a;    // 通过类型转换函数，触发隐式类型转换

1. 同样可用于隐式类型转换（没有主动写转型代码）
2. 写法类似于运算符重载函数，让编译器可以将该对象作为string型数据处理

struct Data
{
    int id;
    string name;
};




Data d = {1000, "Anotts"};    // aggregate initialization

• 对于const或者&类型的变量，必须初始化。
• 对于没有定义默认构造函数的类，其对象必须初始化

A(const A& a): A(a.id, a.name) {...}  // 同样推荐用初始化列表哦    

A& operator=(const A& a) {...}    // 重载=运算符要考虑的情况往往更多，如原本已有值的情况该怎么处理（拷贝构造就不用管这点），自赋值等

~A() {...}

• 用于正号（只有一个参数）A operator+(const A& a) { return a;}
• 用于加法（处理两个参数）A operator+(const A& a, int d) { return A(a.id+d, a.name);}

• 带int参数，为后置递增（要保留初值并返回）
• 不带参数，为前置递增

• 用于单例模式
• 用于静态类

• 用于禁止用户对此类型的变量进行定义。要创建对象，只能用 new 在堆上进行！
• 用于禁止用户在程序中使用 delete 删除此类型对象。对象的删除只能在类内实现！

int getId() const { return id;}    // 通常getData函数是只读的


// 常量对象只能调用常成员函数
const A a;   a.getId();    

mutable int varId;    // mutable变量永远可变，甚至当它是const对象的成员时也是如此

const int& getId() { return id;}  // 其实只有在返回引用时才有用，表示该返回值不可修改
const int& getId() const;         // 可以重载，似乎用于匹配不同情形的用法

class A{
friend void Func(A& a);    // 声明Func为友元函数，类外定义
friend void B::Func();     // 声明类B的Func为本类的友元函数


friend class B;        // 声明类B为本类友元


int friends(const A& a)    // 可以访问a的私有成员
{ return a.id + int(a.name); }}

class String
{
public:
    String(const char *cstr = "");   // new char[strlen(cstr)+1]
    String(const String &other);     // strcpy(data, other.data)
    ~String();                       // delete[] data
    String& operator=(const String &other);       // if (this == &other) {return *this; delete[] data.. new}
    String operator+(const String &other) const;  // strcat(newString.data,other.data)
    char* get_c_str() { return data;}
private:
    char *data;    // 本质
};

• 机器字长 指运算器进行定点数运算所能处理的二进制数据位数
• float和int一起运算会转换为double
• 定义全局变量系统会自动初始化，而局部变量会为随机值（栈内存）

int a[] = {0,1,2,3};         // 列表自动初始化大小
int(* p)[4] = &a;            // 数组指针，必须指向4元素大小的数组 
 a+1 = a + sizeof(int)       // 数组迭代器
&a+1 = a + sizeof(int[4])    // 获取数组尾后元素的地址
len = sizeof(a)/sizeof(int); // 计算len的一种方式
int*(& rA)[3] = int* pA[3];  // 这是一个指向指针数组的引用

• vector::iterator it 容器迭代器
• const_iterator 常量迭代器，只可读不可写
• (*it).front / it->second 都可以访问对象的成员，这里分别是map的key和value
• inserter 插入迭代器
• iter+1 表示迭代到下一元素，可以由此实现at
• 迭代器循环中增删元素容易造成段错误：访问的内存超出了系统给程序的内存空间

• 函数的类型（方法签名）：返回类型+形参类型
• 函数指针声明：bool (*pf)( const string&, const string& );
• pf指向函数：pf = (&)lengthCompare;
• pf调用函数：(*pf)( "Hello", "goodbye" ); 解引用 不是必须的
• 函数指针的形参写法，bool (*pf)( const string&, const string& )，这里(*)可以省略
• 函数指针为返回值类型的函数：int (*fun(int))(int *, int); 这里fun(int)是函数，外面是函数指针类型，我们把fun(int)当成pf看就懂了：相当于pf fun(int)