晚上饭后抽空看了看如何实现一个内存管理器，涉及内存操作必定少不了指针，恰研究到offsetof这个operator，也看了它的实现，顿有所悟。

先看一段代码：
struct Foo {
        int     a;
        char*   p;
        char    b;
};

Foo* p1 = reinterpret_cast(0);
Foo* p2 = 0;

bool b = (p1 == p2);
std::cout << b << std::endl;

输出结果：
1

请考虑一下虽然打印出来的结果是：1，但是这两个赋值语句的意义相同吗？？？

Foo* p2 = 0;
相信所有C++的初学者都知道，这句的意思是p2是一个空指针，或者说p2尚未指向任何对象。

Foo* p1 = reinterpret_cast(0);
那么这句呢？难道p1也是如p2一样，是一个空指针么？

我们再回顾一下一般我们给指针赋值都是如何做的：
Foo* p = new Foo();
或
Foo aFoo;
Foo *p = &aFoo;

无论是new Foo()还是&aFoo，实际上他们返回的都是一个地址常量，类似于0xffbff204这样的地址值，我们就不妨假设new Foo()或&aFoo返回的地址常量值就为0xffbff204。

继续！我们将如何解释一个指针呢？在Stanley B. Lippman的鸿篇巨制'C++ Primer 3rd'中的第3.3小节有这样的叙述：
每个指针都有一个相关的类型。… … 指针的类型可以指示编译器怎样解释特定地址上内存的内容以及该内存区域应该跨越多少内存单元。

好了，我们解释一下Foo *p = 0xffbff204; (或Foo *p = (Foo*)0xffbff204 或Foo *p = reinterpret_cast(0xffbff204) 更好一些，因为Foo *p = 0xffbff204;这样的语句在C++中很可能不能通过编译，并提示'invalid conversion from `unsigned int' to `Foo*'之类的错误')
我们有这样一个Foo类型的指针，其指向一个起始地址为0xffbff204的类型为Foo的对象，这样我们可以通过&(p->b)得到b的地址：即在0xffbff204的基础上再加上成员b在结构体中的偏移量，如偏移量是8，我们得到的b的地址就是0xffbff204 + 8d。

现在我们把0xffbff204换成了0，也就是Foo* p1 = reinterpret_cast(0); 其实我们再告诉编译器：我们有这样一个Foo类型的指针，其指向一个起始地址为0×0的类型为Foo的对象。这时如果我们想得到b的地址，我们一样可以通过&(p->b)获得，即在0×0的基础上再加上成员b在结构体中的偏移量，如偏移量是8，我们得到的b的地址就是0×0+ 8d = 8，其实这就是b在结构体里面的偏移量。

有些人一直在担心，p1指向地址为0处，一旦引用p1会不会出问题，请牢记这里我们并没有做dereference操作，即*p操作，而且获取b的地址实际上编译器是通过p1以及b的偏移量来计算得来的，也不涉及到dereference操作。你也可以理解为有一个'虚拟'的Foo object就存储在0×0这个地址上，呵呵。越过脑子中的那个阴影向前一步便会豁然开朗。

不进一步分析了，一般offsetof的实现如下：
#define offsetof(type, f) ((size_t)((char *)&((type *)0)->f – (char *)(type *)0))
有了上面的阐述相信理解这个宏定义应该不难。

用C++的写法：std::cout << reinterpret_cast<size_t>(&((reinterpret_cast<Foo*>(0))->p)) << std::endl;
不知道上面我的逻辑是否适合大家。^_^

关于Functions，Bjarne Stroustrup在'The C++ Programming Language'一书中是这么开篇的：'The typical way of getting something done in a C++ program is to call a function to do it.'；另外他还阐述了一个使用Functions的原则：'A function cannot be called unless it has been previously declared.'。

函数的声明和定义要一致，这里的一致是指函数名字、返回类型和参数列表(不包括参数名字)的一致。参数名字是被编译器ignored的，所以在声明时你完全可以不显式写出参数名：
int func(char*, int); // a declaration with no explicit argument names
当然从代码的可读性等考虑，还是建议声明时写上参数名：
int func(char* array, int size);

声明和定义的参数名字可以不相同，编译器关注的是参数列表的各个参数类型。
int func(char* c, int i); //a declaration
int func(char *array, int size) {…} // a definition

这里补充一点就是如果你给某个函数声明了一个参数，你在实现这个函数时最好用上这个参数。

使用或者调用一个函数就涉及到另外两个方面了：参数传递(Argument passing)和函数返回值(Return value)。参数传递和函数返回值在语义上等价于变量初始化(initialization)，与变量赋值(assignment)语义有区别。

这里首先区分一下变量初始化(initialization)与变量赋值(assignment)：
很显然变量初始化发生在这个变量生命周期的最开始阶段，任何一个变量的生命都源于编译器给它分配一块存储区域，而初始化就紧跟在内存分配之后，用初始值覆盖这块内存，通过这两步操作完成一个对象(无论是built-in还是user-defined)的建构，换句简洁的话说：初始化是用来创建对象的，是创建对象的一个步骤；在未执行该步骤时，这个对象从语义上讲还不存在；而变量赋值操作则是修改一个对象，这个对象在被赋值之前已经存在了，有自己的存储空间并且已经有过初始化操作，是一个语义上真实存在的对象；赋值操作仅仅是改变了那块内存区域的值或者是bit序列分布而已。

上面说过参数传递(Argument passing)从语义上相当于变量初始化，那么当一个实参(Actual argument)被传递给一个函数后，究竟是哪个变量被初始化了或者说被创建了？初始化过程又是如何呢？举例说明：
int func(T value_formal_arg, T* ptr_formal_arg, T& ref_formal_arg); //这是一个函数声明，囊括了passed by value, passed by pointer, passed by reference全部三种参数传递方式

int main() {
 //…
 int rv = func(value_actual_arg, ptr_actual_arg, ref_actual_arg);
 //…
}

在参数传递过程中，完成了三个对象的创建，上面的func函数在传参的时候相当于：
int func(…) {
 T value_formal_arg = value_actual_arg;
 T* ptr_formal_arg = ptr_actual_arg;
 T& ref_formal_arg = ref_actual_arg;
 
 //接下来使用value_formal_arg，ptr_formal_arg和ref_formal_arg
}
从此可以看出，三个在function scope内的临时变量被在栈上分配内存，并分别被三个实参初始化了。当然有时候传进来的实参不能直接用于初始化，编译器要进行类型检查，看看传进来的实参是否匹配形参类型，对于兼容的类型做标准的或者用户自定义的implicit type conversions，对于完全不匹配的报告编译错误。
void print(int i) {…}

double d = 1.0;
print(d); //这里在传参的时候需要做一个将实参d转型为int型的implicit type conversion

void handle(int &i);

handle(1); //这里由于形参为non-const reference，而初始化语义不支持将常数直接用来初始化non-const reference，所以这里编译器会报告一个编译错误

说完了参数传递过程，接着看函数返回过程。前面同样提到了函数返回的语义也相当于变量初始化，那么我们同样要问这样一个问题：函数返回的过程中返回值到底用来创建哪个对象了？

T func(…) {
 //…
 return t; //t是T类型的
}

T rv;
rv = func(…);
当func返回时，返回值是用来初始化rv了么？根据上面我们所说的initialization和assignment的区别，我们可以断定这显然不是。那么返回值又是初始化哪个对象了呢？这里又有一个临时对象产生了。上面的语句等价于：
T rv;
T temp = t; //func的返回值t被用来创建一个临时对象temp
rv = temp; //这个临时对象最终被用来对rv进行assignment了

在C++中，以by value方式返回一个对象是效率不高的，特别是当返回复杂的user-defined类型时，其带来了额外的构造、拷贝构造和析构的损耗。在Scott Meyers的'More Effective C++'书中的条款20讲解了如何编写代码来配合编译器的'Return Value Optimization, RVO'优化技术，当编译器开启这种优化后，像上面我们的例子可以这么写：
T rv = func(…);

函数返回过程也许就会被优化成:
T rv = t;

C++的Function还提供了Default arguments机制，这里要注意的就是当函数有多个参数的时候，应该如何提供默认参数。比如：
void func(int a = 1, int b = 2, int c = 3); // ok
void func(int a, int b = 2, int c =3); // ok
void func(int a, int b, int c = 3); // ok
void func(int a = 1, int b, int c); // error

int main() {
 func(); //call func(1, 2, 3)
 func(5); //call func(5, 2, 3)
 func(5, 7); //call func(5, 7, 3)
}
知道void func(int a = 1, int b, int c);为什么错了吧？比如我调用func(5, 7);这实参5是传给a还是传给b呢？显然编译器不能resolve，那就只能给你报告错误了^_^。