int f(int) {}

int f(const int) {}

以上两个函数不能出现在同一个编译单元，编译器无法区分他们。

int f(int&) {}

int f(const int&) {}

以上两个函数可以出现在同一个编译单元，编译器可以区别他们。

我们需要了解一下编译器如何进行重载解析的。

重载解析是一个比较复杂的过程，编译器将做如下工作：

1）通过被调用函数的名字和参数列表来确定一个或者一组可行函数

2）在可行函数中确定是否有一个最佳可行函数，如果有使用它，否则出错

这里说到的可行函数包括：普通函数和函数模板，被调用的函数的实参能够隐式的向可行函数的形参转换或者函数模板能够实例化为需要的函数。

例如：

int f(int); #1

int f(void); #2
int f(double); #3

void f(int, int); #4

void f(long); #5

template<class T> void f(T); #6

int f(int*); #7

我们这样使用：

short sNum = 1;

f(sNum);

经过编译器分析，将得到一个由 #1, #3, #5, #6 组成的可行函数列表。显然，这里 short 类型的对象能够向 int, double, long 进行隐式转换，而函数模板则可以实例化为 void f(short)。

接下来编译器将寻找一个最佳可行函数。寻找最佳可行函数的策略如下（对于现代 C++ 编译器来说）：

1）是否有类型完全匹配的函数，如果有则这个函数是最佳可行函数

2）是否有函数模板存在，如果有则这个函数模板为最佳可行函数

3）函数实参是否能够通过提升转换找到匹配的函数，例如 short 类型对象向 int 类型转换就是提升转换，float 向 int 也是提升转换，如果有这样的函数，则为最佳可行函数

4）函数实参是否能够通过标准转换找到匹配的函数，例如 int 类型对象向 short 类型转换或者 double 类型向 float 类型转换，如果有这样的函数，则为最佳可行函数

5）是否存在用户定义的转换（例如类声明的转换），如果转换可行，那么就是最佳函数

6）找不到最佳函数，失败。

测试程序如下：

void f(int)
{
 std::cout << "f(int)" << std::endl;
}

void f(void)
{
 std::cout << "f(void)" << std::endl;
}

void f(double)
{
 std::cout << "f(double)" << std::endl;
}

template <typename T>
void f(T)
{
 std::cout << "f(T)" << std::endl;
}

int main(int argc, char* argv[])
{
 short sNum = 1;
 f(sNum);

 return 0;
}

延迟：完成给定事务所花费的时间（例如，50 ms）

对于一个 60 FPS 的游戏来说，意味着服务器对每个用户的任何一次请求的响应在 1000 / 60 ms 内完成，用户将感觉非常流畅。

我们必须首先找到性能的瓶颈，然后克服瓶颈，克服瓶颈的一个有效的手段是为瓶颈增加资源（例如更好的主机或者网络）

发现和解决瓶颈：

首先我们需要收集信息，特别指收集用户请求到得到响应的时间以及服务器的内在消耗（例如服务器的 OnTimer）。

<1> CPU 的影响是最小的

现代服务器运行十分高效，通常在微妙级完成大量计算，如果因为 CPU 出现性能问题，我们可以使用更加高效的 CPU 或者优化我们的程序，例如优化对容器的操作，诸如 std::map 这样的容器，在数据量极大的情况下，插入是低效的。频繁的 new 和 delete 是低效的，如果有必要，我们可以收集需要删除的对象而不是真正的删除对象。

<2> 内存的读写对性能影响较小

对内存的读写一般来说影响是小的，但是应该注意 std::vector 等容器的内存分配方式，频繁的内存拷贝是较为低效的。

<3> 文件 IO 和数据库 IO 影响较大

文件的 IO 和数据库 IO 是比较低效的，我们通常都要尽量使用异步 IO，而一般情况下数据库 IO 都伴随则网络的 IO，因此我们应该尽量减少数据库 IO，尽量更新内存镜像而不是直接写库。

a. 在合理的范围内，在服务器启动时，载入数据库中的数据。

b. 除了非常重要的数据之外的数据，都没有必要立即写库，取而代之是修改内存的镜像，为了确保安全（例如避免服务器崩溃时玩家损失过大），可以定时将内存数据同步数据库，这种同步可以分散到秒级，例如，我们服务器拥有 1000 名玩家，每个玩家 10 分钟同步一次数据，通常我们不会在第 10 分钟同时保存 1000 名玩家的数据，而是在每秒钟（1000 / 60 * 10 = 1）或者每两秒钟保存一个玩家的数据

c. 尽量使用异步数据库 IO

d. 一般来说，玩家离线后，其相关数据就从内存中删除，如果某玩家需要读取离线玩家的数据，可以使用异步 IO。

e. 所有数据全部置于内存是可能的，我们可以查询相关的技术，当然高效率的同时带来了高成本。

<4> 网络 IO 影响最大

没有必要的服务器端和客户端的数据同步开销巨大。网络底层通常使用 IOCP（Windows）、Epoll（Linux）、Kqueue（Freebsd）或者使用 ACE 等技术，当然也可以使用一些特殊的手段（参考云风《IOCP, kqueue, epoll 有多重要》）。

最终网络和计算机硬件的发展对 MMOG 服务器开发有非常重要的影响，如果辅助存储器 IO 效率能够同主存储器一样高效，如果网络 IO 效率能够达到访问辅助存储器的效率（而这些都是可能的），那么 MMOG 服务器开发将是完全另外一番景象了。

VC8 支持编译适用于 desktop/server Windows、Windows CE 和 Windows Mobile 平台的库。

ACE_wrappers 目录下的：

ACE.sln 适用于 VC7.1

ACE_vc8.sln 适用于 VC8，用于编译适用于 desktop/server Windows 平台的库

ACE_WinCE.sln 适用于 VC8，用于编译适用于 Windows CE/Moblie 平台的库

1. 按需要使用 MSVC 打开相关的 sln 文件

2. 在 ACE_wrappers\ace 目录下创建 config.h 文件，写入：
#include "ace/config-win32.h"
3. 如果你希望使用标准的 C++ 头文件（例如 iostream、cstdio 等）在 #include "ace/config-win32.h" 前加入：
#define ACE_HAS_STANDARD_CPP_LIBRARY 1

4. 如果你希望使用 MFC 库，那么 config.h 中加入：

#define ACE_HAS_MFC 1

如果你希望使用 MFC 静态库，那么加入：

#define ACE_USES_STATIC_MFC

5. 如果你希望编译静态版本的 ACE 库，那么在 config.h 中加入：

#define ACE_AS_STATIC_LIBS

6. 如果你希望减少静态库的大小，可以禁止使用 inline，在 config.h 的 #include "ace/config-win32.h" 前加入：

#define ACE_NO_INLINE

ACE 的基础是：

1. ACE OS adaptation

2. C++ wrapper facades

它们封装了 OS 的并发网络编程机制

1）ACE OS adaptation 层封装了 OS API，对上层提供 OS 平台无关的接口。

2）C++ wrapper facades 层位于 OS adaptation 之上，提供了与之相似的功能，这些功能使用 C++ 的类封装起来，而不是 C 语言 API。每个 wrapper facade 都包含一个或者一个以上的类。我们可以有选择的继承、聚合这些 wrapper facade。

3）框架层（Framework layer）

框架层在 C++ wrapper facades 层之上，它集成和扩充了 wrapper facade 类。

<1> 事件多路分离和分发框架

ACE Reactor 和 ACE Proactor 实现了 Reactor 模式和 Proactor 模式。

<2> 连接建立和服务初始化框架

ACE Acceptor-Connector 框架实现了 Acceptor-Connector 模式。

<3> 并发框架

ACE 提供了 Task 框架实现了并发模式。

<4> 服务配置框架

ACE 的服务配置框架实现了 Component Configurator 模式。

<5> 流框架

ACE 的流框架实现了 Pipes and Fiters 模式。

4）ACE 网络组件层

组件（component）就是软件系统中被封装的一个部分，ACE 发行包中的组件用于提供以下功能：

<1> 演示 ACE

<2> 提供常见网络服务的可复用实现。如提供日志记录、时间同步等服务的可复用实现。

1）通过 Proc 类创建 Proc 对象

2）通过 Kernel.proc 创建 Proc 对象

<1> 通过 Proc 类创建 Proc 对象

a_proc = Proc.new {|a, b| a} # 后接 Block

<2> 通过 Kernel.proc 创建 Proc 对象

a_proc = Kernel.proc {|a, b| a} # 后接 Block

方法 lambda 和 proc 同于类方法 Kernel.proc：

a_proc = lambda {|a, b| a}

a_proc = proc {|a, b| a}

两种创建 Proc 对象的方式稍微有区别，具体来说在调用 call 方法时有区别：

<1> 通过 Proc.new 创建 Proc 对象

a_proc = Proc.new {|a, b| a} # Block 带有 2 个形参

a_proc.call(1, 2, 3) # call 方法带有 3 个实参

运行正常

<2> 通过 Kernel.new 创建 Proc 对象（lambda、proc 相同）

a_proc = lambda {|a, b| a} # Block 带有 2 个形参

a_proc.call(1, 2, 3) # call 方法带有 3 个实参

执行异常：

wrong number of arguments (3 for 2) (ArgumentError)

继承的一个最大的缺点就是带来了高耦合，这仅仅次于友元。

继承的优点主要有几个：

1）使用通用的方式操作子类对象

2）仅仅需要修改基类方法的实现，使得各个子类的行为改变，而无需一个一个的改变子类的实现

我们必须慎用，否则无法利用到继承带来的好处，反深受其害。

下面给出几个标准：

1）基类的方法要符合基类的身份，而不是为了使用某个方法而定义某个方法。这样设计出来的基类，才不至于在需求变更时招到致命的打击。

2）区分什么是抽象基类，什么是接口，如果出现以下的情况，我们都需要考虑一下：

<1> 我的接口有两个或者两个以上的类去继承它

<2> 我的抽象基类只有一个类去继承它

除非你和明确你这样做的用意，否则这些现象可能是某种不当设计的警示灯。

关于接口和抽象类，参考：http://www.i170.com/user/killercat/Article_109853

2. 要么完全使用智能指针，要么完全不用指针指针。最好是完全使用它。特别在多个容器保存同一个对象的指针时，务必使用智能指针。

一般我们把智能指针保存在容器里面，这么做首先能够为我们释放内存提供方法，其次也保证了在复杂逻辑下也能完全避免野指针。一会使用智能指针，一会不使用智能指针的做法是不明智的，就算不会引起任何问题，也不是一个好的习惯。

3. 小心处理递归组合的问题

4. 一个函数完成多个任务是绝对错误的

你当然可以这么做，把多个任务写在一个函数里面，甚至通过一个参数的值来决定应该完成什么样的功能，但是当一个函数需要完成多个任务时，它的体积变大了，这不仅仅是影响了可维护性，也影响的可读性，这样的代码在需求变更下会显得很不稳定。

5. 出现重复代码是绝对不允许的

重复的代码出现绝对是噩梦，继承的一个目的就是减少重复的代码，没有人希望在需求变化时，去修改几乎相同的代码，这是容易出错的，也是低质量代码的一个标志。这种代码可维护性差。

6. 构造你的基础设施，使得你的容错代码不再那么恶心，把 assert 融入进去

单纯的容错代码是恶心的，至少它把 bug 隐藏了起来，使得不那么容易分辨。当然，开发人员不希望发生什么意外的 Crash，因此用容错代码把这个系统死死的包裹起来，不可否认单纯的容错代码的确在一定程度上保障了系统的稳定。这里不是告诫大家不要使用容错性代码，而是保证在错误发生时，错误本身是被暴露给了开发者，而不是被忽略掉了。达到这个目的需要构架一些基础设施，最好的办法是把 assert 融入。

7. 对代码效率做理性的估计

一些极端的人在写代码时考虑非常多，最极端的人甚至害怕 if 是否会影响到效率，当然 if 语句相对于其他语句来说相对耗时，然后这种时间的损耗是几乎无法检查的。诸如此类的问题，我们必须给予理性的分析。理性的最常用手段是定量，由于笔者是开发游戏服务器的，可以参考：http://www.i170.com/user/killercat/Article_112475 来看待效率问题。

8. 要知道什么东西是危险的，知道它为什么危险

c++ 语言或者 stl 库里面有一些很危险的东西，常常需要我们注意，例如：

void SetName(std::string strName)

{

    m_strName = strName;

}

// 调用

void main()

{

    char* pszName = NULL;

    // 一些代码

    SetName(pszName); // 危险，能否保证 pszName 是否不为空？

}

在很多书籍强调使用 string 代替 char 数组的时候，你是否想过 string 也有危险的地方，对于：

std::string strName = NULL;

strName.length(); // 行为未定义

除了要知道危险何在，还要清楚一些危险的东西险在哪里，例如可变长参数，参考：http://www.i170.com/user/killercat/Article_111683，此文指出来变长参数带来的问题，知道了变长参数那里比较危险，那么我们就可以合理的使用它，而不是完全的抛弃它。

需要我们注意的陷阱很多，需要大家在实践中慢慢积累。

9. 小的问题在复杂的项目中将被放大

一些小的问题，也许大家觉得没有什么，但是在复杂的逻辑中，在一些条件下（例如程序员精力不足，环境比较吵闹等）很可能就出现了，甚至被放大，最终导致了很严重的后果。因此我们必须处处小心。

我们先来看一个例子：

int main()
{
 __int64 n64Num = 10;
 bool bGood = true;

 // 输出结果为 10 0
 printf("%d %d", n64Num, bGood);

 return 0;
}

对于上面这个程序，不注意，还以为输出结果是 10 1，由此程序引入本文讨论的主题 ------ 变长参数。

首先我们需要达成一个共识：变长参数关闭了编译器对类型的识别和隐式转换。

1）共识：变长参数关闭了编译器对类型的识别和隐式转换

使用带变长参数的函数，只能通过第一个参数来判断匿名参数的个数和类型，而编译器本身是无法识别的，换而言之，编译器对参数类型识别的功能被关闭了。我们来看一个函数：

// 接受一个 int 类型的参数

void Func(int nNum)
{
 std::cout << nNum << std::endl;
}

// 比较使用变长参数和不使用变长参数

int main()
{
 double dNum = 10;

 // 使用非变长参数函数处理 dNum
 Func(dNum);

 // 使用变长参数的函数处理 dNum
 printf("%d\n", dNum);

 return 0;
}
运行上面的程序，输出结果是：

10

0

通过这个程序，我们可以很明显的看出带有变长参数的函数和一般函数的差别，函数 Func 进行了参数的隐式转换，这个是编译器帮助程序员完成的，而对于变长参数，编辑器没有办法识别参数的类型，无法进行类型转换，因此出现了错误的结果。

我们看一个真实项目的缩影：

__int64 GetID()
{
 return 10;
}

bool IsDie()
{
 return true;
}

int main()
{

 // 错误的结果
 printf("%d %d\n", GetID(), IsDie());

 return 0;
}
我们看到了，使用函数 GetID() 时，程序员没有注意到它的返回类型，因此错误发生了。或者你有可能遇见这样的情况，最初函数 GetID() 的返回值为 int，程序能够正常运行，后来由于种种原因，GetID() 的返回值变成了 __int64，那么错误产生了，这样的错误不容易发现。

2）解决之道

很多书籍都告诫我们，要慎用变长参数，甚至有一些书籍鼓励程序员完全抛弃变长参数。这里，笔者认为，在一定的条件下，可以合理的使用。

这里，笔者建议这样使用：

printf("%d %d", (int)GetID(), (int)IsDie());

即对每一个匿名参数进行显式类型转换，或者这样用：

int nID = GetID();

int bDie = IsDie();

printf("%d %d", nID, bDie);

即：帮助编译器完成类型转换的工作。

#include <iostream>
#include <conio.h>

class CTest
{
public:
    int Func(int nNum);
private:
    int m_nNum;
};

int CTest::Func(int nNum)
{
    return nNum;
}

int main()
{
    CTest* pTest = NULL;
    CTest* pTest2;
    CTest* pTest3 = new CTest;
    delete pTest3;

    std::cout << pTest->Func(10) << std::endl;

    // 在 VS2003 下，应该注释此行再运行
    std::cout << pTest2->Func(10) << std::endl;
    std::cout << pTest3->Func(10) << std::endl;

    system("PAUSE");
    return 0;
}

读者可以在 MSVC6，VS2003，GCC 下测试本程序，除了 VS2003 下，需要注释"std::cout << pTest2->Func(10) << std::endl;"之外，程序都能正常运行。

我们可以得到这样一个结论，如果某成员函数没有访问成员变量，那么无论指针的值如何，对此成员函数的访问通常是有效的。

这种技巧被称之为奇技淫巧并不为过，不过云风有一文《更健壮的 C++ 对象生命期管理》谈及到它的用法（笔者对此持保留态度）。一般来说，我们是不会使用这种技巧的。我们来看看真实项目中的一个缩影：

// Thing
class CThing
{
public:
    void Dosomething();
};


// Thing Manager
class CThingMgr
{
public:
    // Check
    bool Check(int nID);
    // Remove
    void Remove(int nID);
    CThing* GetThing(int nID);
private:
    std::map<int /*ID*/, CThing*> m_mapThing;
};

bool CThingMgr::Check(int nID)
{
    // Do something without variables
    return true;
}

void CThingMgr::Remove(int nID)
{
    std::map<int, CThing*>::iterator it = m_mapThing.begin();
    if (m_mapThing.end() == it)
        return;

    m_mapThing.erase(it);
}

使用：

CThing* pThing = mapThing->GetThing(nID);
// 做了很多事情之后
mapThing->Remove(nID);
// 又做了很多事情
pThing->Dosomething(); // 这里 pThing 已经被删除

我们可以看到，如果函数 Dosomething 没有访问 CThing 的成员变量，那么运行将很正常。假如某天，某个维护此代码的人员加入了一些访问成员变量的代码，那么程序将崩溃，并且这种错误非常难以发现（特别是维护人员和开发人员不是同一个人时）。

我们可以考虑使用一些技术来解决这个问题，在此笔者经过分析考虑认为使用智能指针来解决是最佳方案。

C++ 中的整形有 8 种，包括 char, short, int, long 以及它们的无符号版本。C++ 的整形的大小是平台依赖的，不同平台可能表现出不同的大小，但是也有一定的规定：

<1> short 至少是 16 bits

<2> int 至少和 short 一样长

<3> long 至少是 32 bits 并且至少和 int 一样长

目前来说（2008/09/17），在 32 bits 的操作系统平台上，short 为 16 bits，int 为 32 bits，long 为 32 bits

在头文件 climits（limits.h）中定义了符号常量表示了整数类型的信息，例如定义了 INT_MAX 表示了 int 类型能够保存的最大值，定义了 CHAR_MAX 表示 char 类型的最大值等。

C99 添加了 2 个新的类型，long long 和 unsigned long long，这两种类型至少是 64 bits，并且它们至少和 long 和 unsigned long 一样长。

2. 整形的溢出问题

<1> 无符号数的溢出

unsigned int nNum = 0xffffffff;

++nNum; // nNum 为 0

注意，nNum 表示了一个 32 bits 的内存区域，当溢出发生时，绝对不会影响到这 32 bits 区域之外的区域，下同。

<2> 有符号数的溢出

int nNum = 0x7fffffff; // INT_MAX
++nNum; // nNum 为最小的整数 0x80000000

对于有符号数的表示法，可以参考：http://www.i170.com/user/killercat/Article_110496

3. 字符常量

C++ 中，有三种不同的方式（十进制、八进制、十六进制）来书写整形常量，我们通过 Literals 的前两位来表示整形常量的基数（n 进制）：

第一位为 1 - 9，表示是一个十进制数（基数为 10）

例如：std::cout << "Year: " << 2008 << std::endl;

这里的字符常量（Literals）2008 将被存储为什么样的类型？答案是，如果没有其他理由（例如，使用了后缀），那么将其储存为 int 类型。字符常量的后缀决定了字符常量被存储的类型：

2008l 或者 2008L ---- long 类型常量

2008ul 或者 2008UL ---- unsigned long 类型常量

1101 表示了十进制的 13（2^3 + 2^2 + 0 + 2^0 = 13）

二进制数不方便书写和阅读，十六进制数用一位表示了二进制的四位便于阅读和书写：

1101 表示十六进制的 D（A 表示 10），注意，对于十六进制的表示中的 A，B，C，D，E，F 是不区分大小写的，也就是说 a 表示 10，b 表示 11 等也是可行的。

1. X 进制的数和十进制数的转换

对于 X 进制的数和十进制数的转换公式是：

对表达式 (X^(n-1))*m 求和，其中 n 表示位数，m 表示本位的值，例如：

十六进制数 --- 9D7A

对于第 4 位：(16^(4-1))*9 = 36864

对于第 3 位：(16^(3-1))*13 = 3328

对于第 2 位：(16^(2-1))*7 = 112

对于第 1 位：(16^(1-1))*10 = 10

求和 36864 + 3328 + 112 + 10 = 9D7A，即是十六进制的 9D7A 表示十进制的 40314

2. 二进制和十六进制的转换

二进制的四位对应了十六进制的一位，因此，我们可以这样转换：

100 1000 1101

从右到左取 4 位：1101 表示 D（把这个四位二进制数先转换位十进制数，然后用十六进制数表示，下同）

再取 4 位：1000 表示 8

剩余 3 位：100 表示 4

因此，100 1000 1101 可以转换为 48D 这个十六进制数

3. 十进制转换为 X 进制

做法：除 X 取余，例如：

1000 转化为 16 进制数：

1000 / 16 = 62 余 8 ---- 8 为最低位

62 / 16 = 3 余 14 ---- 14 为次低位

3 / 16 = 0 余 3 ---- 3 为最高位

结果是：1000 = 3E8

当然，最简单的办法就是用计算器了，只要一个按钮，就可以完成转换 ^_^

4. 字符的表示

计算机只能保持 10 序列，而不能直接保持字符，因此我们通过建立字符和 10 序列的映射，通过保存 10 序列来保存字符，这种映射被称为之编码。字符和 10 序列到底以何种方式隐射，这就由编码方式决定，ASCII 就是常见的编码方式，例如它规定了用 43（1000011）表示大写的 'C' 字符：

// ASCII 编码方式举例
int main()
{
    const int SIZE = 18;

    // 按 ASCII 编码方式对字符串 "Computers are fun." 进行编码
    int output[SIZE] =
    {
        0x43, 0x6f, 0x6d, 0x70,
        0x75, 0x74, 0x65, 0x72,
        0x73, 0x20, 0x61, 0x72,
        0x65, 0x20, 0x66, 0x75,
        0x6E, 0x2E
    };

    for (int i=0; i<SIZE; ++i)
        printf("%c", output[i]); // printf 函数按照 ASCII 编码方式进行解码

    return 0;
}

ASCII 中的规律：

1）小写字母和大写字母的码（Code）是连续的，例如：

int main(void)
{

    // 术语 code 即是 01 序列
    char cLetter;
    for (cLetter='a'; cLetter<='z'; ++cLetter)
        std::cout << cLetter << " ";

    for (cLetter='A'; cLetter<='Z'; ++cLetter)
        std::cout << cLetter << " ";

    return 0;
}

2）大写字母和对应的小写字母的第 6 位分别是 0 和 1：

'A' ---- 1000001

'a' ---- 1100001

因此：'a' - 'A' = 2^5 = 32

'b' - 'B' = 2^5 = 32 等