标签：c++

在C++中，如果不为某个struct/class实现一个构造函数，那么编译器就会自动为这个类添加一个默认构造函数，而这个默认构造函数什么也不干。

但是我却从来不知道，默认构造函数在不同的情况下，会出现不一样的效果（当然这是C++03之后的标准).

先看一段代码:

struct test {
int a;
int b;
};



void *operator new(size_t sz)
{
void *p = malloc(sz);
for (size_t i = 0; i < sz; i++)
((char *)p)[i] = 0x01;
return p;
}
int main()
{
struct test *t1 = new test;
struct test *t2 = new test();
printf("t1:%x-%x\n", t1->a, t1->b);
printf("t2:%x-%x\n", t2->a, t2->b);
return 0;
}


重载new操作符是为了把分配出来的内存弄脏。然后观察new test和new test()的区别。

结果出人意料，t1的值就是内存中被污染的值，然后t2的值却全部被清0，而造成这种现象的惟一的区别就是new之后类型是否带有括号。

这就是C++03版本的新增内容，当没有实现构造函数时，编译器为你自动生成的构造函数是有两种用途的。当你在使用new T()构造对象时，默认的构造函数会对各变量执行清0操作，其实应该就是memset为0. 而在使用new T来构造对象时，其默认构造函数是任何事也不做的。

总觉得这么做违背了语言的一致性的设计， 但是不管怎么说有了这个，在写struct定义时在一定的情况下就可以省掉默认构造函数了。

一直以来都是通过C用基于对象的设计方法来写代码。即使工作中使用C++， 也是尽可能少的使用超出C的一些特性。当然这并不是C++不好，而是C++实在太复杂了。以我的脑力来讲， 如果使用C++过多的特性， 很容易让我过于陷入语法特性之中， 而忽略了设计。因此， 对于C++的一些高级特性， 如模板等并没有深入研究过。

模板对我来讲， 仅限于知道可以实现泛型。至于怎么巧妙的利用泛型来实现其他特性， 从来没有深入研究过。最近工作中，碰到了一些看起来比较高端的模板用法，令人有一种耳目一新的感觉，因此就记录一下。

---

如果实现一个单纯的组播模块， 该模块提供的组播接口可能类似：

void multicast(func, arg1, arg2, arg3, ...);

在不用模板的情况下，假设每种参数有可能有m种类型，如果参数的个数为n个。 那么针对参数为n个的函数就需要手写m^n个重载板本。

使用模板推导功能，对于参数个数为n个的函数，就仅仅只需要实现一个实现即可。

示意代码大概如下：

template
int call(void (*func)(T1 p1, T2 p2), T1 p1, T2 p2)
{
func(p1, p2);
}
void func1(int a, float b)
{
printf("%d, %f\n", a, b);
}
void func2(double a, const char *b)
{
printf("%lf, %s\n", a, b);
}
int main()
{
call(func1, 3, 3.5f);
call(func2, 5.3, "hello");
return 0;
}

这样使用模板忽略掉了参数类型，仅仅针对参数个数进行重载， 会大大提高代码的编写效率。

---

对于C++来讲，其实RAII应该算是惯用手段了。

在不使用模板的情况下，如果我们使用RAII来管理指针，我们就需要为每一个类实现一个指针类。而如果使用模板，仅仅实现一个指针类就可以了。

比如：

template
class PTR {
public:
PTR(T a) {
ptr = a;
};
~PTR() {
if (ptr == NULL)
return;
delete ptr;
};

T get() {
return ptr;
};
private:
T ptr;
};

class test {
public:
test() {printf("test\n");}
~test() {printf("~test\n");}
void hello() {printf("%s\n", h);}
void set(const char *n) {h = n;}
private:
const char *h;
};

int main()
{
PTR p(new test);
test *t = p.get();
t->set("hello");
t->hello();

return 0;
}

其实上面的代码大致就是C++11提供的std::unique_ptr实现的功能了.

---

在网络通信过程中，定义数据结构总是一件很烦的事，使用纯C的数据结构便于传输，但是会将结构定义的很死, 而且数据种类有限。

如果使用vector/unordered_map并且相互嵌套时传输就会很麻烦。一般这时候就不得不采用protobuf的方式来进行传输。

但是有时候你要传输的数据结构仅仅就是vector/unordered_map等动态数据结构的一些嵌套， 这时候去使用protobuf就稍嫌重量了。

这时其实可以结合C++的模板推导及参数重载来实现一个简易的数据序列化库。

大概试了一下vector，用起来还是很方便的。

template void
serial(const T &a, std::string &res)
{
res.append((char *)&a, sizeof(a));
}

template size_t
unserial(T &a, const char *p)
{
a = *(T *)p;
return sizeof(T);
}

template void
serial(const std::vector &a, std::string &res)
{
size_t n = a.size();
res.append((char *)&n, sizeof(n));
for (size_t i = 0; i < n; i++) serial(a[i], res); } template size_t
unserial(std::vector &a, const char *p)
{
size_t pos;
size_t n = *(size_t *)p;
a.reserve(n);
pos = sizeof(size_t);
for (size_t i = 0; i < n; i++) { T tmp; pos += unserial(tmp, &p[pos]); a.push_back(tmp); } return pos; } int main() { std::vector src1 = {1, 2, 3, 4, 99, 100};
std::vector src2;
std::string dst;

serial(src1, dst);
unserial(src2, &dst[0]);

for (size_t i = 0; i < src2.size(); i++) printf("%d ", src2[i]); return 0; }

---

从上面三个模板的例子上看，基本上模板就是强类型语言用来在写代码时弱化类型的一个折中。如果有过动态语言编写经验就会明显感觉到，模板明显是为了有限的支持动态语言在编写时的一些优点。如果能够把握这一点，也许才能够更合理，也更巧妙的去运用模板。

今天快下班前听到他们正在讨论说某个bug可能是编译器优化导至的bug, 我当时正在忙其他事也就没有参与讨论，下班回来的路上想到了编译器优自然而然就想到了volatile关键字。

随手上百度搜了一下，得到的结论令我大吃一惊，说什么的都有，有说阻止编译器优化，还有说用于多线程并发，还有说影响cpu cache，总之说什么的都有。其他的我不敢说，但是至少编译器级别的优化还达不到cpu cache的层次，毕竟我搞过一段时间的无锁算法的，对cpu的cache原理有一定的了解。

至于真相到底是什么，也只能自力更生，验证一下了，虽然我平时尽量不用代码或尽量使用伪码说明问题，奈何这是一篇验证性的文章，相关的C代码和汇编肯定是少不了的。

我写了段代码分别测试了一下局部变量，局部指针变量，全局变量，静态全局变量分别是volatile和非volatile的情况，使用gcc -O2 -S a.c来编译以下C代码：

#include "stdlib.h"
#include "stdio.h"

int gg = 1;
static int xx = 1;

int test()
{
        gg = 0;
        xx = 0;
        return 0;
}

int main()
{
        //test the local variable
        int a = 0;
        a += 3;
        a += 4;
        printf("%d\n", a);

        //test the volatile local variable
        volatile int b = 0;
        b += 3;
        b += 4;
        printf("%d\n", b);

        //test the local memory pointer
        int *c = (int *)malloc(4);
        *c = 0;
        *c += 3;
        *c += 5;
        printf("%p, %d\n", c, *c);
        //test the variable local memory pointer
        volatile int *d = (int *)malloc(4);
        *d = 0;
        *d += 3;
        *d += 5;
        

        //test the global variable
        while (gg) {
                printf("helloworld\n");
        }

        //test the static global variable
        while (xx) {
                printf("helloworld\n");
        }

        return a;
}

产生的汇编代码如下：

.section __TEXT,__text,regular,pure_instructions
.globl _test
.align 4, 0x90
_test: ## @test
.cfi_startproc
## BB#0:
pushq %rbp
Ltmp2:
.cfi_def_cfa_offset 16
Ltmp3:
.cfi_offset %rbp, -16
movq %rsp, %rbp
Ltmp4:
.cfi_def_cfa_register %rbp
movl $0, _gg(%rip)
movb $1, _xx(%rip)
xorl %eax, %eax
popq %rbp
retq
.cfi_endproc

.globl _main
.align 4, 0x90
_main: ## @main
.cfi_startproc
## BB#0:
pushq %rbp
Ltmp8:
.cfi_def_cfa_offset 16
Ltmp9:
.cfi_offset %rbp, -16
movq %rsp, %rbp
Ltmp10:
.cfi_def_cfa_register %rbp
pushq %rbx
pushq %rax
Ltmp11:
.cfi_offset %rbx, -24
leaq L_.str(%rip), %rbx
movl $7, %esi
xorl %eax, %eax
movq %rbx, %rdi
callq _printf
movl $0, -12(%rbp)
addl $3, -12(%rbp)
addl $4, -12(%rbp)
movl -12(%rbp), %esi
xorl %eax, %eax
movq %rbx, %rdi
callq _printf
movl $4, %edi
callq _malloc
movq %rax, %rcx
movl $8, (%rcx)
leaq L_.str1(%rip), %rdi
movl $8, %edx
xorl %eax, %eax
movq %rcx, %rsi
callq _printf
movl $4, %edi
callq _malloc
movl $0, (%rax)
addl $3, (%rax)
addl $5, (%rax)
cmpl $0, _gg(%rip)
je LBB1_3
## BB#1:
leaq L_str3(%rip), %rbx
.align 4, 0x90
LBB1_2: ## %.lr.ph4
## =>This Inner Loop Header: Depth=1
movq %rbx, %rdi
callq _puts
cmpl $0, _gg(%rip)
jne LBB1_2
LBB1_3: ## %.preheader
movb _xx(%rip), %al
testb %al, %al
jne LBB1_6
## BB#4:
leaq L_str3(%rip), %rbx
.align 4, 0x90
LBB1_5: ## %.lr.ph
## =>This Inner Loop Header: Depth=1
movq %rbx, %rdi
callq _puts
movzbl _xx(%rip), %eax
cmpl $1, %eax
jne LBB1_5
LBB1_6: ## %._crit_edge
movl $7, %eax
addq $8, %rsp
popq %rbx
popq %rbp
retq
.cfi_endproc

.section __DATA,__data
.globl _gg ## @gg
.align 2
_gg:
.long 1 ## 0x1

.zerofill __DATA,__bss,_xx,1,0 ## @xx
.section __TEXT,__cstring,cstring_literals
L_.str: ## @.str
.asciz "%d\n"

L_.str1: ## @.str1
.asciz "%p, %d\n"

L_str3: ## @str3
.asciz "helloworld"

.subsections_via_symbols


对比局部变量a和volatile局部变量b可以看出：
a被优化成了一个寄存器%esi, 而关于a的操作被优化成一个常量赋值。
而b的所有操作均没有被优化，b的每次存取操作均是直接操作栈上内存。

对比局部指针变量c和volatile局部指针变量d：
向*c和*d的赋值的最后一步均为直接写入内存，但是对于c指针所指向内存的加法则被优化成了常量赋值，而对于d指针所指向内存的所有操作均没有被优化。

再看对于全局变量和静态全局变量的访问和修改，均是直接读写或修改内存，并不使用cpu的寄存器做优化。

那么使可以得出以下结论：
volatile关键字使得所有操作此变量的操作均不会被优化（如优化为寄存器或操作合并）
即使对于对内存和全局变量进行一些优化操作（如将连续的加合并为一个常量赋值），在最后一个操作时一定会将所得的值存入内存（即其效果一定看起来等效于原来的语句）。
也就是说除了不想编译器合并对某个变量的操作和不想编译器将某一局部变量优化成寄存器，我们几乎没有使用volatile的地方（这一准则同样适用于嵌入式领域)

现在开始反驳一些结论：
1. 多线程通过变量交互，需要使用volatile变量。
如果使用变量进行多线程通信， 那么这个变量必然是全局的，如上所述全局变量是会即时写入内存的，并不存在所谓的寄存器残留问题, 也就不需要使用volatile.

2. 在中断程序中需要修改变量时，此变量一定是volatile变量（嵌入式系统）
同结论1相似，如果中断程序可以访问此变量，而应用程序也可以访问些变量，则此变量至少一定是静态全局变量，同样不需要volatile。

3. 影响cpu cache。
除了使用cpu自带的无锁汇编指令或lock汇编指令，其他的汇编是不能够影响cpu cache的。关于这个问题是可以参考Intel参考手册的。

ps.虽然我一向不喜欢做大自然的搬运工，但还是做了一次。