TcpConnection::handleClose()

    将自身状态设置为kDisconnected;

    禁用Channel的读写；

    进行connectionCallback_回调：

        connectionCallback_由TcpServer指定，而在TcpServer中connectionCallback_又由用户指定，
        因此它实际上是用来通知上层应用程序，连接即将关闭，请进行相关处理；

    进行closeCallback_回调：

        closeCallback_实际上绑定的是TcpServer::removeConnection，也就是TcpServer对TcpConnection的管理。

        首先从连接表中删除该连接，然后在通知TcpConnection对象，你已经从TcpServer中移除了，
        请自身再做一些处理，即调用TcpConnection::connectDestroyed()（从EventLoop中删除自身所对应的Channel）。

        closeCallback_放在最后一行执行并用shared_ptr保护起来，使得函数调用完毕、TcpServer中移除了对其的引用后，
        自身的内存能得到释放（shared_ptr的引用计数为1）。

1. Changing private member variables of a class does not require recompiling classes that depend on it, thus make times are faster, and the FragileBinaryInterfaceProblem is reduced.
2. The header file does not need to #include classes that are used 'by value' in private member variables, thus compile times are faster.
3. This is sorta like the way SmallTalk automatically handles classes... more pure encapsulation.

1. More work for the implementor.
2. Doesn't work for 'protected' members where access by subclasses is required.
3. Somewhat harder to read code, since some information is no longer in the header file.
4. Run-time performance is slightly compromised due to the pointer indirection, especially if function calls are virtual (branch prediction for indirect branches is generally poor).

1. Put all the private member variables into a struct.
2. Put the struct definition in the .cpp file.
3. In the header file, put only the ForwardDeclaration of the struct.
4. In the class definition, declare a (smart) pointer to the struct as the only private member variable.
5. The constructors for the class need to create the struct.
6. The destructor of the class needs to destroy the struct (possibly implicitly due to use of a smart pointer).
7. The assignment operator and CopyConstructor need to copy the struct appropriately or else be disabled.

 1  // foo.h
 2 
 3   class foo_impl;
 4 
 5   class foo {
 6     // Boilerplate
 7     friend class foo_impl;
 8     foo() {} // so only foo_impl can derive from foo
 9     const foo_impl * impl() const;
10     foo_impl * impl();
11   public:
12     virtual ~foo() {}
13     // Factories
14     static std::auto_ptr<foo> create(int value);
15     // Interface
16     int value() const;
17   };
18 
19   // foo.cpp
20 
21   class foo_impl : public foo {
22     friend class foo;
23     // Constructors mirroring the factory functions in foo
24     explicit foo_impl(int value) : value_(value) {}
25     // Member data
26     int value_;
27   };
28 
29   inline const foo_impl * foo::impl() const {
30     return static_cast<const foo_impl *>(this);
31   }
32   inline foo_impl * foo::impl() {
33     return static_cast<foo_impl *>(this);
34   }
35 
36   std::auto_ptr<foo> foo::create(int value) {
37     return std::auto_ptr<foo>(new foo_impl(value));
38   }
39 
40   int foo::value() const { return impl()->value_; }
41 
42