// Singleton 模板

template <typename T>
class Singleton
{
public:
    Singleton()
    {
        assert(!ms_singleton);
        ms_singleton = static_cast<T*>(this);
    }
    ~Singleton()
    {
        assert(ms_singleton);
        ms_singleton = 0;
    }
    static T& GetSingleton()
    {
        assert(ms_singleton);
        return *ms_singleton;
    }
    static T* GetSingletonPtr()
    {
        return ms_singleton;
    }
protected:
    static T* ms_singleton;
};

// 使用模板（省略了原有的大量代码）

class _OgreExport LogManager : public Singleton<LogManager>, public LogAlloc
{
public:

    LogManager();
    ~LogManager();
    static LogManager* GetSingletonPtr(void);

    static LogManager& GetSingleton(void);
};

OGRE 中使用引擎本身去调用构造函数的方式初始化 Singleton，而我们常见的 Singleton 都是第一次调用 GetSingleton 来创建实例，另外 Singleton 本身也不负责释放 ms_singleton。实际上，分离构造和析构使得更加容易使用在多线程的环境中，读者可以阅读 ACE 中 Singleton 的实现方式（n 种实现）。

笔者做了一点小的修改：

#define SINGLETON_DECLARE(T) static T& GetSingleton(); static T* GetSingletonPtr();
#define SINGLETON_IMPLEMENT(T) template<> T* Singleton<T>::ms_singleton = 0;\
    T* T::GetSingletonPtr() { assert(ms_singleton); return ms_singleton; } \
    T& T::GetSingleton() { assert(ms_singleton); return *ms_singleton; }

template <typename T>
class Singleton
{
protected:
    Singleton()
    {
        assert(!ms_singleton);
        ms_singleton = static_cast<T*>(this);
    }
    ~Singleton()
    {
        assert(ms_singleton);
        ms_singleton = 0;
    }
protected:
    static T* ms_singleton;

    // Hide
private:
    Singleton(const Singleton&);
    void operator=(const Singleton&);
};

// 使用代码

class MyMgr : public Singleton<MyMgr>
{
public:
    SINGLETON_DECLARE(MyMgr)
    void SayHello();
};

SINGLETON_IMPLEMENT(MyMgr)

void MyMgr::SayHello()
{
    cout << "Hello world!" << endl;
}

命名必须要注意的两点：

1）永远不要使用晦涩的名字

2）总是使用全大写字母表示宏和常量

匈牙利命名法：

匈牙利命名法的一个特点是将类型信息混入名称中，例如：

int nNum = 0; // n 为类型信息，表明 nNum 是一个 int 类型

class CUser; // C 为类型信息，表明 CUser 是一个类

通常的观点认为，在名称中加入类型信息会增加代码的可读性，实际上，这种效果甚微。加入类型信息的不良表现之一是降低可维护性，一个很简单的例子：

class CUser

{

private:

    int m_nID;

}

如果出现某种情况导致需要修改 m_nID 的类型为 long，那么 m_nID 应该改名字为 m_lID，那么意味着要在整个类中修改 m_nID。更糟糕的情况是：

class CHome

{

public:

    void f();

}

void CHome::f()

{

    int nID = m_pUser->GetID(); // nID 需要改成 lID

   // 下面大量使用 nID

}

可见，CHome 中的 f 函数的局部变量 nID 在 id 类型由 int 变成 long 时也受到了影响。

总的来说是将类型信息引入名称中致使维护成本增加，我们本无需因为类型的改变维护名称，匈牙利命名法将类型绑定在名称上，使得必须在类型变动时维护名称。

在泛型编程中，几乎无法使用匈牙利命名法，因为具体的类型信息并不存在。

除非你使用纯文本编辑器，否则名称中加入类型信息的做法不会为你增加任何可读性（现代的 IDE 甚至是一些高级文本编辑器，在你用鼠标点击到变量名称上时，就能显示变量的类型），它已经过时了。

一套可行的命名规范：

1）类名、枚举名、结构名、联合名、typedef 定义的类型名、函数名可以使用 LikeThis 的命名方式。

2）变量名使用诸如 likeThis 的命名方式（首字母小写）

3）类成员变量名前加 m_ 例如：

class User

{

    int m_id;

}

全局变量前加 g_ 例如：

int g_id;

静态变量使用 s_ 例如：

static int s_id;

这里说明一下，为什么需要把作用域和链接性信息融入名称中：

<1>变量作用域和链接性改变的情况是很少的，例如，很少的情况下会把一个成员变量改成静态变量

<2>编程中使用的工具常常不会直观的显示变量的作用域和链接性

<3>在许多高质量的代码中，均不同程度的将作用域信息融入变量名称中（通常使用 "_" 来表明其作用域）

对于静态类成员变量，通常使用如下方式表示：

template <typename T>

class Singleton

{

protected:

    static T* ms_instance; // 作用域前于链接性

}

4）宏和常量使用 LIKE_THIS 的命名方式

5）namespace 使用小写字母命名

个体和交互：一个优秀团队由具有较强交互能力和编程能力的成员组成，其中交互能力重要性胜于编程能力。所谓的交互并不限于人与人面对面的交流，还可以是其他多种方式。

工具：使用简单而不是复杂的工具，直到有足够理由表明需要使用更多的功能才进行更换。

2. 可以工作的软件胜过面面俱到的文档

文档在描述系统原理和结构相比代码更有优势，然而过多的文档将浪费大量的时间（编写和维护的时间），即一个团队应该包含的文档：

1）描述系统原理和结构的文档

2）代码（从代码中提起系统原理和结构信息可能是困难的）

人之间的交互是学习系统的原理和结构系统的最快的方式。

总的来说：直到迫切需要并且意义重大时，才编写文档。

3. 客户合作胜过合同谈判

客户通过丢下一份关于你想要软件的描述，然后固定时间和价格让人开发，这通常会导致项目的失败。

成功的项目需要频繁的客户反馈，让开发团队和客户一起工作并且经常提供反馈。（开发团队和客户需要频繁的交互）

4. 响应变化胜过遵循计划

详细的计划在面临需求变动时，显得不再适用，较好的做法是计划为下两周做详细的计划，为下三个月做粗略的计划，之后的做极为粗略的计划。团队成员需要清楚最近应该做的详细的任务，粗略了解之后需要实现的需求。

int day = 20081227 // 用一个数表示年、月、日

而不是我们常见的：

// 使用 3 个整数表示

int year;

int month;

int day;

可见第一种方式比较节约内存，在网络传输上有一定的优势，解析的时候，使用：

(day / 10000) % 10000 // 年

(day / 100) % 100 // 月

(day / 1) % 100 // 日

归纳起来就是：

对于内存中连续的区域（命名为 mem），把这段区域被分成 x 个固定大小组成部分（x >= 1），每个组成部分称之为这个区域的一个块

如果使用整数来表示这个区域，则可以使用公式 (mem / (10 ^ n)) % (10 ^ m) 来解析各个块，这里 n 表示这个块最低位在整个区域中的位置，m 表示这个区域的长度。

如果使用非整数来表示这个区域，例如：

struct mem // 24 bits

{

    char mem1;

    char mem2;

    char mem3;

};

解析起来就稍显麻烦了。我们可以使用 STL 的 bitset 而不是上面的结构，那样更加方便。

但是最终，我还是不建议使用此类方式来节约内存，原因有一下几点：

1）通常情况下，内存不会是稀缺资源

2）使用上述方式解决必定使得源码可读性降低

3）使用者必须遵循原定契约（每个块多长，表示什么意思），契约的出现必定增加一定的复杂度，使得错误更加容易产生

因此，除非必要，否则不要使用这种手段。

另外，我们还可以看到一种按位使用的情况，即是：每一位表示一种状态

01 // 第一位表示男性还是女性，第二位表示是否结婚，那么 01 就表示未婚男性

上面是一个简单的例子，实际使用中可能有更加复杂的情况，我们在如下情况下可以使用：

1）状态只有正反两面

2）状态相互独立（最好能满足这条）

3）状态数量很多（最好能满足这条）

在满足上述 3 个条件的情况下，使用也不会带来多大的坏处，甚至比别的实现方式更好。

1）参数压栈的时候，如果是整形，那么小于 4 字节的都将提升为 4 字节，例如：

char c = 'a';

printf("%d", c); // 这里实参 c 将提升为 4 字节

另外 bool 类型也将提升为整形

float 类型将提升为 double 类型

2）所有参数在内存上是连续的，例如：

int a, b;

f(a, b); // 这里 a, b 两个变量的地址之差是 sizeof(int)

看一些问题：

bool first = true;
int second = 10;

// 输出 1 10，这里 first 被提升为 4 字节
printf("%d %d", first, second);

// 输出有问题的情况

__int64 first = 20; // __int64 在笔者机器上是 8 字节
int second = 10;

// 输出 10 0，这里 %d %d 取的是 first 的低 4 位和高 4 位，而没有取到 second
printf("%d %d", first, second);

// 浮点类型

float first = 20;
int second = 10;

// 输出 0 1077149696，由于浮点类型的表示不同于整形，所以输出此结果

// 但依然是取 first 的低 4 位和高 4 位，这里 first 首先提升为 double 类型
printf("%d %d", first, second);

我们看一下变长参数的实现：

// 保证 _INTSIZEOF(n) 的结果为：如果 sizeof(n) 小于 sizeof(int) 则为 sizeof(int)

#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
#define va_start(ap,v)  ( ap = (va_list)&v + _INTSIZEOF(v) )
#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define va_end(ap)      ( ap = (va_list)0 )

仔细分析 #define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )

这里 ~(sizeof(int) - 1) 保证了最后 sizeof(int) - 1 位是 0，其余为 1，那么在 int 为 4 字节的环境中，其结果就是 1111 1111 1111 1111 1111 1111 1111 1100 那么同 sizeof(n) + sizeof(int) - 1 相 & 的结果是后 2 位必须为 0，也就是说，只能为 4，8，12 ...

另外，还需要说一下：

#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )

这里 ap 是一个指针，ap += _INTSIZEOF(t) 又减 _INTSIZEOF(t)，也就是说 va_arg 运算的结果就是当前 ap 的地址，然后在运算结束之后，ap 已经移动了 _INTSIZEOF(t) 通过 += 运算。换一种表示就是：

tmp = ap;

ap += _INTSIZEOF(t);

return tmp;

1）Lua 中使用函数来表示迭代器

2）为了迭代的进行必须保存状态用于表示当前在容器中的位置此外还需要保存迭代的对象

3）for 的文法如下

for <var-list> in <exp-list> do

    <body>

end

泛型 for（generic for）会保存 3 个值：

<1> 迭代函数（迭代器）

<2> 不变状态（invariant state）

<3> 控制变量（var-list 中的第一个变量就是控制变量）

这 3 个值由 exp-list 计算得来且仅计算一次，换而言之 exp-list 将初始化 for 循环保存的 3 个值，而这 3 个值中，通常只有控制变量会在循环中改变。如果 exp-list 计算出来的值多于 3 个，那么就被丢弃，少于 3 个将补 nil。

控制变量如果它为 nil，循环结束。这里 var-list 是迭代器返回值。

注意，每次调用迭代器，不变状态和控制变量将作为参数传递到迭代器中。那么迭代器函数（f），不变状态（is），控制变量的关系就是（cv）：

cv = f(is, cv)

这里详细阐述一下迭代器和控制变量的关系，迭代器的第一个返回值将赋值给控制变量，控制变量又将作为迭代器的第二个参数传递到迭代器中。

在不同的用法中，不变状态通常都被赋值为一个容器

2. 使用闭包表示迭代器时

1）状态保存在外部局部变量（external local variable）中

2）迭代器总是被迭代器工厂创建

3）每一次调用 for 循环都需要创建一个闭包，在某些情况下，可能需要考虑性能问题

4）使用闭包表示迭代器是一种最简单的方式，它的实现不需要遵循任何契约

5）范例

arr = {"one", "two", "three", "four"}

function iter_factory(arr)
    local curr_index = 0
    local len = table.getn(arr)
    return function ()
        curr_index = curr_index + 1
        if curr_index <= len then return arr[curr_index] end
    end
end

for v in iter_factory(arr) do
    print(v)
end
 

3. 使用普通函数

1）状态由泛型 for（generic for）来保存，具体来说是由 for 的控制变量来保存状态，用不变状态来保存迭代的对象（collection）

2）迭代器不需要在每次循环时创建而是作为一个函数的返回值

3）性能相比闭包情况时要好

4）范例

arr = {"one", "two", "three", "four"}

function iter(arr, cur_index)
    cur_index = cur_index + 1
    local v = arr[cur_index]
    -- must return cur_index first(control variable)
    if v then return cur_index, arr[cur_index] end
end

function iter_init(arr)
    -- return iterator, invariant state, init control variable
    return iter, arr, 0
end

for i, v in iter_init(arr) do
    print(v)
end

4. 其他

本文不介绍多状态的迭代器，因为多状态的迭代器并不优雅，创建表的开销要大于创建闭包的开销，访问表的域也比访问外部局部变量慢，如果需要多状态时，建议使用闭包实现方式。

local fact = function (n)
    if n == 0 then
        return 1
    else
        -- 这里 fact 还没有被创建
        return n * fact(n - 1)
    end
end

使用以下语法定义局部函数：

local function fact(n)
    if n == 0 then
        return 1
    else

        -- Ok
        return n * fact(n - 1)
    end
end

另外说明一下函数定义的前置声明（forward declaration）：

-- 前置声明
local f, g
 
function g ()
    f()
end
   
function f ()
    g()
end

-- use table
p = {1, 2}
 
-- use closure
function point(x, y)
    return function (index)
        if index == "x" then return x
        elseif index == "y" then return y
        else return x, y end
    end
end
 
p = point(1, 2)

2. 使用闭包来完全替换一个函数的实现

-- 替换 math.sin 的实现，原有的 math.sin 实现被完全隐藏并提供了新的实现（使用度数而非弧度）

do
    local oldSin = math.sin
    local k = math.pi / 180
    math.sin = function (x)
        return oldSin(x * k)
    end
end

-- 替换 io.open 的实现，使得我们可以控制对文件的访问

do
    local oldOpen = io.open
    io.open = function (filename, mode)
        -- access_OK 指定那些文件可以访问
        if access_OK(filename, mode) then
            return oldOpen(filename, mode)
        else
            return nil, "access denied"
        end
    end
end

3. 函数的参数使用闭包

函数的参数使用闭包时，效果像 lambda 表达式：

network = {
    {name = "grauna",        IP = "210.26.30.34"},
    {name = "arraial",         IP = "210.26.30.23"},
    {name = "lua",             IP = "210.26.23.12"},
    {name = "derain",        IP = "210.26.23.20"},
}

-- table.sort 就是一个典型的例子
table.sort(network, function (a,b)
    return (a.name > b.name)
end)

cycles of shared_ptr instances 的意思是：一个 shared_ptr 实例直接或者间接的保存了自身的实例，例如：

// ------------------------

class CTest
{
public:
    ~CTest();
    void SetNext(boost::shared_ptr<CTest> pNext);
private:
    boost::shared_ptr<CTest> m_pNext;
};

// 资源无法释放

int main()
{

    // pTest 的引用计数为 1
    boost::shared_ptr<CTest> pTest(new CTest);

    // pTest 的引用计数为 2
    pTest->SetNext(pTest);
    return 0;

    // pTest 析构之后，应用计数减 1，资源未释放（泄漏）
}

// ------------------------

在大量使用 shared_ptr 时，必须注意这个问题，我们可以使用 weak_ptr 来解决这个问题。

又注意到:
a0,a1的数据类型,说明与X表的a0,a1数据类型相同.这就是%TYPE的妙用了.

如果说明一个结构变量与X相同,可以用%ROWTYPE,如下:
x0 X%ROWTYPE
其实,程序中的x0就是X%ROWTYPE类型.在FETCH时放入了值.如果用OPEN显式操作,则可以:
FETCH c INTO x0;
一次性将所有值放入.

// 比较任意的两个对象的大小，需要 operator< 支持
template <typename T>
inline T const& max(T const& a, T const& b)
{
 return a < b ? b : a;
}

// 用于比较两个 C 风格的字符串
inline char const* max(char const* a, char const* b)
{
 return std::strcmp(a, b) < 0 ? b : a;
}

// 比较任意的三个对象的大小
template <typename T>
inline T const& max(T const& a, T const& b, T const& c)
{
 return max(max(a, b), c);
}

int main()
{
 char const* pszName1 = "killercat1";
 char const* pszName2 = "killercat2";
 char const* pszName3 = "killercat3";

 // 编译器警告：返回局部变量或临时变量的地址
 std::cout << max(pszName1, pszName2, pszName3);

 return 0;
}

出现警告的原因在于 return max(max(a, b), c) 中的 max 函数编译器选择了 char const* max(char const* a, char const* b) 这个版本，而这个版本返回的是一个临时变量，这个临时变量被三参的函数模板 max 返回出去，这显然出现了问题。

《C++ Templates》上面给出了建议是：只改变那些需要改变的内容。这里笔者认为根本不应该提供一个非函数模板来表示特殊情况，而应该定义显示具体化的模板：

template<>
inline char const* const& max(char const* const& a, char const* const& b)
{
 return std::strcmp(a, b) < 0 ? b : a;
}

至少我们在写出这样的代码时：

template<>
inline char const* max(char const* a, char const* b)
{
 return std::strcmp(a, b) < 0 ? b : a;
}

编译器会报错。

跨OS有什么好处？

最大的好处就是降低开发成本。

VC++是最好的c++研发工具，就是VC6版本，至今也难有敌手。但unix的研发人员也是人啊，没日没夜地用gdb命令找bug也不是好玩的。用跨OS的方略，则问题变得easy。

资源

我们使用的跨平台库的OS相关部分是从XmailServer中来的。

使用XmailServer有几个原因：
够小，简洁，有效。

一个高级程序员，完全可以在一天内读完XmailServer的跨平台部分的封装。

XmailServer最近进行了升级。其源码将unix的进行了合并处理，有空请研究：
http://www.xmailserver.org.cn/
我用的是上一代的版本。

注意点

跨平台，不仅仅是跨OS，还有32/64的差别，需要考虑。当然，XmailServer在头文件中已经将数据类型剥离出来了，只要逐个检查，按具体环境设置即可。
千万别省略这个步骤，不然，出了问题要花比该步骤长N倍的时间。

就命名为：xsys.*吧。

附件说明

我先上传了一点，供下载。

开源的同学们编程没有问题，封装的接口不够抽象简洁，以至于普通程序员望而生畏。

这个的封装，可谓厚积薄发，平易近人，请观摩。