#ant

@攀升
“原型模式”目前还没有研究过，如果最近有时间的话可能会写一篇

新更新了源代码下载，可惜没注释
可能哪天会加上注释和文档，呵呵...

@googoodolls
没问题

@杨粼波
Loki的我看过，不过感觉太复杂，也许有时候需要的只是最简单的

@guemcit
没问题

大家都没有看到我最后一句话：
在后面几篇会有一个多线程安全的，能够解决多个Singleton依赖关系的，基于模板的Singleton实现。

由于篇幅比较长，所以分成好几篇了，thanks！

@L
恩，其实还有很多问题，后面几篇会解决

//std::ptr_fun<void>(&print_functionname);
std::ptr_fun返回的是unary function 或 binary function，不能用于无参函数，实际上也没必要。

//std::mem_fun1_ref<void,some_class,const std::stirng>(&some_class::print_string)(sc0,"hello2");
如果你用的是Macrosoft的STL，std::mem_fun1_ref会有bug，即只能用于非const成员函数，如果把some_class中的
void print_string(const string& s) const
改为
void print_string(const string& s)

然后再这样写就可以了：
std::mem_fun1_ref(&some_class::print_string)(sc0, "hello2");

当然了，用SGI的STL不会有这个bug
最好的办法是用std::mem_fun_ref，std::mem_fun_ref可用于一个参数或零个参数的const或non-const成员函数，std::mem_fun1_ref只能用于一个参数的const或non-const成员函数，估计是为了兼容性。
所以也可以这样写：
std::mem_fun_ref(&some_class::print_string)(sc0, "hello2");
这样print_string加不加const都一样

有意思
程序员果然“懒”...

Loki库确实经典，不过偶还连STL源码剖析都没时间看完呢

@shaker(太子)
boost::bind确实优雅
上面的bind修改一下应该也可以实现差不多的功能

@ymmol
是啊，不过有像我这样懒的程序员，习惯了将参数推导交给编译器，也习惯了make_pair类似的写法。

双链表还是STL的list比较棒

不错，记得前不久还遇到过处理透明位图的问题。不过当时还不知道
TransparentBlt，是自己另做的掩码位图

有一些道理
不过最后一条我个人认为是因为Java没有C++中的析构函数才有了finally
C++有析构函数还要finally干什么？

不错，学习了。

写得不错，学习C++真辛苦，特别是自己学

不错，不容易

源码没问题，不过写的时候因为时间紧没什么文档，注释也很少。
跟你发了。。。

这个目前还没有研究过，也许google知道

@重剑
oops!!!
delete不小心忘记写了。
把析构函数改成这样就行了：
Thread::~Thread() {
if (_handle != 0)
CloseHandle(_handle);
if (_target != 0)
delete _target;
}

已经更新了下载链接，也可以重新下载。
thanks！

貌似还有一点忘了，就是防治编译器多线程环境下的优化，
这正是volatile关键词的用处

static auto_ptr<T> _instance;
或者用atexit后改成
static T * _instance;
都可能会有问题，因为多线程环境下的变量容易被缓存
所以最好加上volatile

static volatile auto_ptr<T> _instance;
或者用atexit后改成
static T * volatile _instance;

大概看了一下，除了cyt说的Double-Checked Locking，编译器可能会混乱代码的执行次序，即先设置_instance指针的内容再执行构造函数。
还至少有两个问题：
1.
auto_ptr在某些情况下会出问题，假设有某个单例类A在析构时调用另外一个单例类Log来记录一些日志信息，因为在程序结束时静态成员的析构可能会是任意次序，单例类Log很有可能在A调用析构函数之前就析构了，后果就不用说吧。

当然解决方法很简单，用C标准库的atexit就行了，atexit函数原型如下：
int atexit(void (*func )());
用atexit可以注册任意多个函数，当程序结束时会按LIFO的次序调用注册的函数。这样就能保证多个有依赖关系的单例类的析构顺序。
我们修改Singleton的实现，加上：
static void Destroy() {
if ( _instance != 0 ) {
delete _instance;
_instance = 0;
}
}
将Instance实现修改为类似代码：
static T& Instance() {
if (0 == _instance) {
Lock lock(_cs);
if (0 == _instance) {
_instance = new T();
atexit(Destroy);
}
}
return *_instance;
}

2.

_instance.reset ( new T);
或者
_instance = new T();
这里其实还会有问题，在C++中对指针赋值操作并不能保证是原子操作，如果有某个线程1执行到这里，赋值到一半，线程1挂起，线程2开始执行，这时候
_instance可能处于任何状态，0 == _instance 也许为true，线程2于是return *_instance，这时候就会有问题了...

设计一个完美的Singleton也许比想象的要难的多