首先抛出一个问题：为什么需要二级配置器？
因为当我们动态分配内存的时候，分配的内存往往不仅仅是我们需要的那些，还会产生一些额外的开销，比如首尾的cookies，debug模式下产生的额外开销，和内存对齐所产生的pad。这些附加信息，降低了空间的利用率。

于是就设置了二级空间配置器，当开辟小等于128bytes内存时，就视为开辟小块内存，调用二级空间配置器。否则调用一级空间配置器。

一级空间配置器

在一级空间配置器中，最重要的函数有：

• allocate：用于分配空间，申请失败，调用oom_alloc尝试重新申请
• deallocate：用于释放空间
• reallocate：调整已经存在的空间大小，如果调整失败，调用oom_alloc尝试重新申请

其实对应的标准库函数就是malloc，free和realloc。

继承 with virtual function

构造由内而外：首先调用父类的构造函数，然后再调用自己。
析构由外而内：首先执行自己的析构函数，然后调用父类的析构函数。

non-virtual: 你不希望重新定义（重写）它。
virtual: 你希望子类重新定义它，且它有默认定义。
pure virtual: 你希望子类一定要重新定义它，你对它没有默认定义。

1
2
3
4
5
6
7
8
9

class Shape {
  public:
    virtual void draw() const = 0;   // 纯虚函数
    virtual void error(const std::string& msg);   // 虚函数 
    int objectID() const;   // 一般成员函数
};

class Rectangle: public Shape {...};
class Ellipse: public Shape {...};

GCC编译器

GCC 编译器支持编译 Go、Objective-C，Objective-C++，Fortran，Ada，D 和 BRIG（HSAIL）等程序。

实际使用中，使用 gcc 指令编译 C 代码，使用 g++ 指令编译 C++ 代码。

编译过程

例如 g++ test.cpp -o test 可拆解为以下步骤：

内存管理

内存管理详解

内存分配方式

分配方式简介

在C++中，内存分为5个区：

1. 栈：执行函数时，函数内部局部变量存储单元在栈上创建，结束时自动释放。效率很高，但存储容量有限。
2. 堆：由 new 分配的内存块，编译器不会自动释放，需要应用程序对应的 delete 进行释放。如果没有释放，则程序运行结束后会由操作系统自动回收。
3. 自由存储区：由 malloc 等分配的内存块，类似堆，由 free 结束自己的生命。
4. 全局/静态存储区：存储全局变量和静态变量。
5. 常量存储区：存放常量，不允许修改。

Big Three（拷贝构造，拷贝复制，析构）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class String 
{
  public:
    String (const char* cstr = 0);    // 构造函数，默认初值为0
    String (const String& str);       // 接受的值为类本身，因此为拷贝构造函数
    String& operator=(const String& str);  // = 号重载，拷贝赋值函数
    ~String();        // 析构函数，类死亡时自动调用
    char* get_c_str() const { return m_data; }

  private:
    char* m_data; 
}

int main()
{
  String s1();
  String s2("hello");

  String s3(s1);      // 拷贝构造，类还未存在
  cout << s3 << endl;
  s3 = s2;            // 拷贝赋值，类已经存在

  cout << s3 << endl;
}

nullptr

nullptr 出现的目的是为了替代 NULL。传统 C++ 会把 NULL, 0 视为同一种东西，有些编译器会将 NULL 定义为 ((void*)0)，有些则会直接将其定义为 0。C++ 不允许直接将 void 隐式转换到其他类型，但如果 NULL 被定义为 **((void)0)，那么当编译 char ch = NULL;* 时，NULL 只好被定义为 0。而这依然会产生问题，将导致了 C++ 中重载特性会发生混乱，考虑：

1
2

void foo(char *);
void foo(int);

1. 值传递：将主调函数的实参值传递给被调函数的形参，形参单独分配内存。

单向数据传递机制：传递的只是实参的值，形参的改变不影响实参。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include<iostream>
using namespace std;
void swap (int a, int b) {//实现形参a、b的交换
    int c;
    c = a;
    a = b;
    b = c;
}
int main() {
    int x = 2, y = 3;
    swap(x, y);//实参x,y的值并没有交换。值传递的单向数据传递机制
    cout << x<< " "<<y<< endl;//2 3
    return 0;
}

2. 引用传递：被调用的形参引用主调函数的实参，实现间接访问。

双向数据传递机制：通过引用&，指向同一内存，其一改变，二者都改变。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include<iostream>
using namespace std;
void swap (int &a, int &b) {//引用变量a、b，等效int &a=x;int &b=y;
    int c;
    c = a;
    a = b;
    b = c;
}
int main() {
    int x = 2, y = 3;
    swap(x, y);//实参x,y的值被交换。a与x，b与y指向同一内存，其一改变，两者都变
    cout << x<< "和"<<y<< endl;//3和2
    return 0;
}

PS：关于直接和间接访问：

按照C语言的方式，定义一个变量，系统会自动为该变量分配内存，变量有两个属性：变量值和变量地址。变量地址指示该变量在内存中的存储位置，变量值为该内存中的存储内容。

直接访问：直接使用变量名访问内存空间上的内容。

间接访问：先从其它内存空间获得要访问的内存地址（指针），根据地址访问对应内存中的数据。

3. 指针传递：被调函数的形参接收主调函数实参的内存地址，间接访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include<iostream>
using namespace std;
void swap (int *a, int *b) {//引用变量a、b，等效int *a=&x;int *b=&y;
    int c;
    c = *a;
    *a = *b;
    *b = c;
}
int main() {
    int x = 2, y = 3;
    swap(&x, &y);//实参x,y的值被交换。实参地址传递给指针类型的形参
    cout << x<< "和"<<y<< endl;//3和2
    return 0;
}