前置++与后置++

self &operator++() { node = (linktype)((node).next);

return *this;

}

const self operator++(int) { self tmp = *this;

++*this;

return tmp;

}

为了区分前后置，重载函数是以参数类型来区分，在调用的时候，编译器默默给int指定为一个0

1、为什么后置返回对象，而不是引用

因为后置为了返回旧值创建了一个临时对象，在函数结束的时候这个对象就会被销毁，如果返回引用，那么我请问你？你的对象对象都被销毁了，你引用啥呢？

2、为什么后置前面也要加const

其实也可以不加，但是为了防止你使用i++++,连续两次的调用后置++重载符，为什么呢?

原因：

它与内置类型行为不一致；你无法活得你所期望的结果，因为第一次返回的是旧值，而不是原对象，你调用两次后置++，结果只累加了一次，所以我们必须手动禁止其合法化，就要在前面加上const。

3、处理用户的自定义类型

最好使用前置++，因为他不会创建临时对象，进而不会带来构造和析构而造成的格外开销。

std::atomic

问题：a++ 和 int a = b 在C++中是否是线程安全的？

答案：不是

例1：

a++：从C/C++语法的级别来看，这是一条语句，应该是原子的；但从编译器得到的汇编指令来看，其实不是原子的。

其一般对应三条指令，首先将变量a对应的内存值搬运到某个寄存器（如eax）中，然后将该寄存器中的值自增1，再将该寄存器中的值搬运回a代表的内存中

mov eax, dword ptr [a] # (1)

inc eax# (2)

mov dword ptr [a], eax # (3)

现在假设i的值是0，有两个线程，每个线程对变量a的值都递增1，预想一下，其结果应该是2，可实际运行结构可

int a = 0;

// 线程1（执行过程对应上文汇编指令(1)(2)(3)）

void thread_func1() { a++;

} // 线程2（执行过程对应上文汇编指令(4)(5)(6)）

void thread_func2() { a++;

}

我们预想的结果是线程1和线程2的三条指令各自执行，最终a的值变为2，但是由于操作系统线程调度的不确定性，线程1执行完指令(1)和(2)后，eax寄存器中的值变为1，此时操作系统切换到线程2执行，执行指令(3)(4)(5)，此时

eax的值变为1；接着操作系统切回线程1继续执行，执行指令(6)，得到a的最终结果1。

例2：

int a = b; 从C/C++语法的级别来看，这是条语句应该是原子的；但从编译器得到的汇编指令来看，由于现在计算机CPU架构体系的限制，数据不能直接从内存某处搬运到内存另外一处，必须借助寄存器中转，因此这条语句一

般对应两条计算机指令，即将变量b的值搬运到某个寄存器（如eax）中，再从该寄存器搬运到变量a的内存地址中：

mov eax, dword ptr [b] mov dword prt [a], eax

既然是两条指令，那么多个线程在执行这两条指令时，某个线程可能会在第一条指令执行完毕后被剥夺CPU时间片，切换到另一个线程而出现不确定的情况。

解决办法： C++11新标准发布后改变了这种困境，新标准提供了对整形变量原子操作的相关库，即std::atomic，这是一个模板类型：

template<class T> struct atomic:

我们可以传入具体的整型类型对模板进行实例化，实际上stl库也提供了这些实例化的模板类型

// 初始化1 std::atomic<int> value;

value = 99;

// 初始化2 // 下面代码在Linux平台上无法编译通过（指在gcc编译器）

std::atomic<int> value = 99;

// 出错的原因是这行代码调用的是std::atomic的拷贝构造函数 // 而根据C++11语言规范，std::atomic的拷贝构造函数使用=delete标记禁止编译器自动生成

// g++在这条规则上遵循了C++11语言规范。