C++ 内存分区：栈、堆、全局/静态存储区、常量存储区、代码区。

栈：存放函数的局部变量、函数参数、返回地址等，由编译器自动分配和释放。
堆：动态申请的内存空间，就是由 malloc 分配的内存块，由程序员控制它的分配和释放，如果程序执行结束还没有释放，操作系统会自动回收。
全局区/静态存储区（.bss 段和 .data 段）：存放全局变量和静态变量，程序运行结束操作系统自动释放，在 C 语言中，未初始化的放在 .bss 段中，初始化的放在 .data 段中，C++ 中不再区分了。
常量存储区（.data 段）：存放的是常量，不允许修改，程序运行结束自动释放。
代码区（.text 段）：存放代码，不允许修改，但可以执行。编译后的二进制文件存放在这里。

栈和堆的区别

栈是由操作系统自动创建，堆是可以由程序员来进行控制

通常在程序中声明一个变量 如

1
2
3
4
5

int fun1()
{
    int a = 0;
    int *b = new int[];
}

这个变量a就是被创建在栈上，而这个变量b就是被创建在堆上。

栈是由大小限制的，一般来说编译器的默认大小是1M，如果申请的变量过大，有可能造成栈溢出，即StackOverFlow，不过这个大小可以通过配置修改扩大。堆一般就是内存的大小，一般创建在堆上的变量在使用完成后需要程序员自行进行回收，否则会出现不可预知的错误。

内存对齐

C++内存按照编译器的设置，按照内存块来存储的，这个内存块大小的取值，就是内存对齐。

如

1
2
3
4
5
6

struct foo
{
    char a; //1 byte
    int b ; // 4 byte
    short c; // 2 byte
}

sizeof(foo)的大小是12,编译器会将char和short的大小和int的大小进行对齐。

1、第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。

2、在数据成员完成各自对齐之后，类(结构或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。

很明显#pragma pack(n)作为一个预编译指令用来设置多少个字节对齐的。值得注意的是，n的缺省数值是按照编译器自身设置，一般为8，合法的数值分别是1、2、4、8、16。
即编译器只会按照1、2、4、8、16的方式分割内存。若n为其他值，是无效的。

所以如果

1
2
3
4
5
6
7

#pragma pack(1)//设定为 1 字节对齐
struct foo
{
    char a; //1 byte
    int b ; // 4 byte
    short c; // 2 byte
}

这时sizeof(foo)的大小就是7字节

一般的C++程序在编译过程中需要进行如下四步：

预处理(Preprocessing)
预处理用于将所有的#include头文件以及宏定义替换成其真正的内容，预处理之后得到的仍然是文本文件，但文件体积会大很多

1

gcc -E -I./inc test.c -o test.i

上述命令中-E是让编译器在预处理之后就退出，不进行后续编译过程；-I指定头文件目录，这里指定的是我们自定义的头文件目录；-o指定输出文件名。
编译(Compilation)
编译不是指程序从源文件到二进制程序的全部过程，而是指将经过预处理之后的程序转换成特定汇编代码(assembly code)的过程。编译的指定如下：

1

gcc -S -I./inc test.c -o test.s

上述命令中-S让编译器在编译之后停止，不进行后续过程。编译过程完成后，将生成程序的汇编代码test.s，这也是文本文件，内容如下：
汇编(Assemble)
汇编过程将上一步的汇编代码转换成机器码，产生的文件叫做目标文件，是二进制格式。gcc汇编过程通过as命令完成：

1

as test.s -o test.o

等价于

1

gcc -c test.s -o test.o

链接(Linking)
链接过程将多个目标文件以及所需的库文件(.so等)链接成最终的可执行文件

1

ld -o test.out test.o inc/mymath.o ...libraries...

为啥是a.out ？

如果你编写完hello.cpp后，直接使用 gcc hello.c进行编译，你会得到一个a.out程序。
那是由于a.out是”assembler output”的缩写格式，代表汇编程序输出。在较早版本的类unix系统中，a.out是一种输出格式，用于可执行文件，目标文件和共享库。早期的 PDP-7系统上没有链接器，程序的创建过程是先把所有源文件连接成一个文件，然后进行汇编，产生的汇编程序保存在a.out中。这样a.out是名副其实的汇编输出，但到PDP-11之后，人们为其编写了链接器，程序的创建是先编译然后链接输出保存到a.out中，这时a.out其实已经是链接输出了，但输出的可执行文件仍然延续这个命名习惯。
Unix中的可执行文件用一种特殊的方式加上标签，这样便于系统确认它们的属性。普遍采用的方式是使用独特的数字，这些数字也被称为“神秘”数字。一个例子是，Unix文件系统中的superblock就是用下面的数字做标签：
后来，因为构建a.out的复杂性，a.out格式被现在普遍使用的ELF格式所替代，但输出文件名仍旧是a.out。现在我们看到的a.out只是一个可执行文件，而不再是文件格式。ELF可执行文件的第一个字节是八进制177也就是16进制的7F，紧跟其后的2,3,4字节是ELF三个字母。你可以输入od -c a.out | head查看。

链接(Linking)

最终链接分为 静态链接 和 动态链接
静态链接：代码从其所在的静态链接库中拷贝到最终的可执行程序中，在该程序被执行时，这些代码会被装入到该进程的虚拟地址空间中。
动态链接：代码被放到动态链接库或共享对象的某个目标文件中，链接程序只是在最终的可执行程序中记录了共享对象的名字等一些信息。在程序执行时，动态链接库的全部内容会被映射到运行时相应进行的虚拟地址的空间。

参考文档：
https://www.cnblogs.com/ericling/articles/11736681.html
https://zhidao.baidu.com/question/199934360.html
https://www3.ntu.edu.sg/home/ehchua/programming/cpp/gcc_make.html

RxJS 是一个通过使用observable序列来组合异步和时间驱动程序的库。它提供了一个核心类型，Observable, 还有其他类型(Observer, Schedulers, Subjects)，和类似Array中的
操作符, 如(map, filtr, resuce, every, etc)，通过这些来像处理集合一样来处理异步时间。

Think of RxJS as Lodash for events(可以认为RxJS是时间处理中的lodash)

ReactiveX 结合了观察者模式和迭代器模式和集合的函数式编程来满足管理序列化时间的理想方式。

在RxJS中的重要概念主要有：

1. Observable: 代表了一种异步的值或事件的可调用的集合
2. Observer: 是一个知道如何监听通过Observable传递值的回调函数集合
3. Subscription: 代表了Observable和执行, 主要用来取消Observable的执行
4. Operators: 是一种纯函数，使得能够用像map，filter，concat，flatmap等函数操作符来处理集合
5. Subject: 和EventEmitter相同，而且是唯一的方式能够像多个Observer广播值或事件
6. Schedulers: 是用于控制并发的集中调度器， 并允许我们来协调计算比如在使用setTimeout或者requestAnimationFrame时

第一个例子

通常我们这样注册事件

1
2

var button = document.querySelector('button');
button.addEventListener('click', () => console.log('Clicked!'));

如果使用RxJS的话我们可以这么写

1
2
3

var button = document.querySelector('button');
Rx.Observable.fromEvent(button, 'click')
    .subscribe(() =>console.log('Clicked!'));

纯函数

RxJS采用纯函数来产出数据，这意味着有更少的代码错误。

通常你会创造一个不纯的函数来扰乱你的状态。

1
2
3

var count = 0;
var button = document.querySelector('button');
button.addEventListener('click', () => console.log(`Clicked! ${++count} times`));

在RxJS中你可以隔离状态

1
2
3
4

var button = document.querySelector('button');
Rx.Observable.fromEvent(button, 'click')
    .scan(count => count+1,0)
    .subscribe(count =>console.log(`Clicked ${count} times!`));

scan操作符就像是array的reduce操作。

事件流

RxJS 有许多操作符来帮助你控制observables中的事件流

如果用纯JS来控制一个按钮在1s内只能按一次

1
2
3
4
5
6
7
8
9
10

var count = 0;
var rate = 1000;
var lastClick = Date.now() - rate;
var button = document.querySelector('button');
button.addEventListener('click', () => {
    if(Date.now() - lastClick >= rate){
        console.log(`Clicked ${++count} times`);
        lastClick = Date.now();
    }
});

而是使用RxJS的话

1
2
3
4
5

var button = document.querySelector('button');
Rx.Observable.fromEvent(button,'click')
    .throttleTime(1000)
    .scan(count => count+1， 0)
    .subscribe(count => console.log(`Clicked ${count} time`));

流式传值

你能够通过observables来传递值
下面是一个可以通过纯JS来为每一次点击添加鼠标的X坐标

1
2
3
4
5
6
7
8
9
10

var count = 0;
var rate = 1000;
var lastClick = Date.now() - rate;
var button = document.querySelector('button');
button.addEventListener('click', () => {
    if(Date.now() - lastClick >= rate){
        console.log(++count + event.clientX);
        lastClick = Date.now();
    }
});

使用RxJS

1
2
3
4
5
6

var button = document.querySelector('button');
Rx.Observable.fromEvent(button,'click')
    .throttleTime(1000)
    .map(event => event.clientX)
    .scan((count, clientX) => count+clientX, 0)
    .subscribe(count => console.log(count));

Observable

Observables是一种懒加载能够提供多值的集合
可以看下面的表

下面的这个例子是一个Observable 在被订阅的时候立刻输出1，2，3 然后在订阅后1s后输出4，然后结束。

1
2
3
4
5
6
7
8
9

var observable = Rx.Observable.create(function (observer) {
    observer.next(1);
    observer.next(2);
    observer.next(3);
    setTimeout(() => {
        observer.next(4);
        observer.complete();
    },1000);
});

为了调用Observable 我们需要订阅它:

1
2
3
4
5
6
7

console.log('just before subscribe');
observable.subscribe({
    next: x => console.log('got value'+ x),
    error: err => console.error('something wrong occurred:' + err),
    complete: () => consoelg.log('done');
});
console.log('just after subscribe');

这个执行结果会是

1
2
3
4
5
6
7

just before subscribe
got value 1
got value 2
got value 3
just after subscribe
got value 4
done

Pull vs Push

Pull和Push是两种不同的协议用于在数据生产者和数据消费者之间。
什么是Pull? 在Pull系统中由消费者来决定何时来获取数据，每一个jS函数都是一个Pull系统，函数是一个数据生产者，通过调用函数来获取数据。
什么是Push? 在Push系统中，由数据生产者来决定什么时候来向消费者提供数据。Promises 是现在JavaScript中最普遍的Push系统。
RxJS引入了Observable，一种新的push系统，一个Observable是一种多个值的生产者，向Observers(消费者)推送数据。

Observable 和一般化的函数进行比较

和普遍声称的不同，Observables 既不像EventEmitters 也不像多值的Promise。Observables可能在某些情况下像EventEmitters,即当他们使用RxJS Subjects 来广播时，但是通常Observables和EventEmitters不同。

Observables 就像是没有参数的函数，但是包括了那些允许多个值的函数

1
2
3
4
5
6
7
8
9

function foo() {
  console.log('Hello');
  return 42;
}

var x = foo.call(); // same as foo()
console.log(x);
var y = foo.call(); // same as foo()
console.log(y);

通过RxJS

1
2
3
4
5
6
7
8
9
10

var foo = Rx.Observable.create(function(observer){
    console.log('Hello');
    observer.next(42);
});
foo.subscribe(function(x){
    console.log(x);
});
foo.subcribe(function(y){
    console.log(y);
});

这两个的输出都是一样的:

1
2
3
4

"Hello"
"42"
"Hello"
"42"

向一个Observable进行订阅就像是调用一个一般的函数

Observables能够既能同步又能异步传递数据

Observable可以 “return” 多个值。

1
2
3
4
5
6
7
8
9
10
11

var foo = Rx.Observable.create(function(observer){
    console.log('Hello');
    observer.next(42);
    observer.next(100);
    observer.next(200);
});
console.log('before');
foo.subscribe(function(x){
    console.log(x);
});
console.log('after');

可以输出

1
2
3
4
5
6

"before"
"Hello"
42
100
200
"after"

总结

• func.call() 意味着 “给我一个同步的值”
• observable.subscribe() 意味着“给我多个值不管是同步还是异步”

Observable的解析

Observable 通过Rx.Observable.create来创建，通过Observer来订阅，执行来传递next/error/complete来通知观察者，而且这些执行操作可以取消，这就是一个Observable实例的4个方面。

创建Observables

Rx.Observable.create 是Observable构造器的别名，它有一个参数就是subscribe函数
下面这个例子每隔1s产生一个’hi’给Observer，

1
2
3
4
5

var observable = Rx.Observable.create(function subscribe(observer){
    var id = setInterval(() => {
        observer.next('hi');
    },1000)
});

订阅Observables

上个例子中的observable可以这样订阅 observable.subscribe(x => console.log(x));

执行Observables

处理Observable的执行