nt05的记事本

    先从 C 语言开始

比如你有一个 struct
struct test
{
   int x;
   int y;
};

一个处理 test 的函数
void foo(test* p)
{
   p->x = 1;
   p->y = 2;
}

当你有不同的 test 时：
test a, b;
foo(&a);
foo(&b);
由于 foo 的参数是程序员传进去的
如果是 &a 则 p->x 和 p->y 是访问的 a.x 和 a.y
同理，&b 则 p->x 和 p->y 是访问的 b.x 和 b.y

C++ 则有的一点变化，但本质是相同的
class test
{
public:
   int x;
   int y;
   void foo()
   {
      x = 1;
      y = 2;
   }
};

test a, b;

由于函数 void test::foo() 并不在 test 里面！（别奇怪，C++ 的 OM 就是这样的）
而实际上 foo 是一个在全局命名空间的函数，类似于上面的 C 语言中 foo 与 test 的关系。

但当你使用 a.foo() 和 b.foo() 的时候，由于这里的 foo 没有参数
那么编译器不能分辨 foo 到底要处理那一个对象
所以编译器隐含的在foo里面插入了一个参数 this
所以 void test::foo() 实际上是 foo(test* this);
当使用 a.foo() 时，实际上的代码是 foo(&a);
同理 b.foo() 时，实际上的代码是 foo(&b);

void test::foo()
{
   x = 1;
   y = 2;
}
实际上是
void foo(test* this)
{
   this->x = 1;
   this->y = 2;
}

初学者可以不用去深究这些，只要记住每个对象都有一个指向自己的 this 指针

一般情况下只需要了解最基本的两种情况
像下面这样的栈对象
{
   Object t;
}
t 的生命周期就是从定义 t 到 t 所在的那个语句块结束的地方为止
当程序到达 t 所在的那个语句块结束的地方的时候会调用 Object 的解构函数

而像下面这样的堆对象
{
   Object* t = new Object();
   ...
   delete t;
}
t 的生命周期就是从 new Object(); 这一行开始到 delete p 这一行结束
delete p 的时候，会调用 Object 的解构函数
如果你没有 delete p 那么它的生命周期就是到程序结束
不过程序结束的时候不会调用 Object 的解构函数