青青草国产精品久久久久,免费国产99久久久香蕉,久久高潮一级毛片免费

strlen源码剖析

Fri, 12 Oct 2007 05:19:00 GMT

摘要: 学习高效�~�程的有效途径之一��是阅读高手写的源代码，CRT(C/C++ Runtime Library)作�ؓ底层的函数库�Q�实现必焉��效。恰好手中就有glibc和VC的CRT源代码，于是挑了一个相对简单的函数strlen研究了一下，�q�对各种实现作了��单的效率��试。strlen的函数原形如下： size_t strlen(const char *str);strlen�q�回str中字�W�的个数�Q�其... 阅读全文

蚂蚁�l�结�?/a> 2007-10-12 13:19 发表评论

TEA加密��法的C/C++实现

Fri, 12 Oct 2007 05:17:00 GMT

摘要: TEA(Tiny Encryption Algorithm) 是一�U�简单高效的加密��法�Q�以加密解密速度快，实现��单著�U�。算法真的很��单，TEA��法每一�ơ可以操�?4-bit(8-byte)�Q�采�?28-bit(16-byte)作�ؓkey�Q�算法采用�P代的形式�Q�推荐的�q�代轮数�?4轮，最��?2轮。目前我只知道QQ一直用的是16轮TEA。没什么好说的�Q�先�l�出C语言的源代码(默认�?2�?�Q��? v... 阅读全文

蚂蚁�l�结�?/a> 2007-10-12 13:17 发表评论

Mon, 24 Sep 2007 05:01:00 GMT

前段旉��学习Windows�E�序设计�Q�刚好学到Win32 Service�Q�于是写了两个简单的�c�：BaseService和ServiceCtrl。虽然功能比较简单，但是也能适用于大多数情况。下面介�l�一下简单用法，如果你刚好需要写一些简单的服务�E�序�Q�这两个�c�M��许能�z�上用场�Q?br>
1. BaseService
BaseService.h

1 #ifndef BASE_SERVICE_H
2 #define BASE_SERVICE_H
3
4 class BaseService {
5 public :
6     explicit BaseService(LPCTSTR szServiceName,
7                 DWORD dwServiceType = SERVICE_WIN32_OWN_PROCESS,
8                 DWORD dwStartType = SERVICE_AUTO_START);
9     virtual ~ BaseService() {}
10     bool ParseStandardArgs(int argc, char* argv[]);
11     bool IsInstalled();
12     bool Install();
13     bool Uninstall();
14     bool Start();
15 private :
16     virtual void Run() = 0 ;
17     virtual bool OnInitialize() { return true ; }
18     virtual void OnStop() {}
19     virtual void OnPause() {}
20     virtual void OnContinue() {}
21     virtual void OnInterrogate() {}
22     virtual void OnShutdown() {}
23     virtual void OnUserControl(DWORD dwControl) {}
24     ...
25 };
26
27 #endif/*BASE_SERVICE_H*/

要实现自��q��服务�c�d��需从BaseService�l�承�q�且Override相关的virtual函数卛_��Q�下面示范一个BeepService�c�，该服务只是简单地每隔2�U�beep一下，��Z��单所有代码均攑֜�.h文�g中：
BeepService.h

1 #ifndef BEEP_SERVICE_H
2 #define BEEP_SERVICE_H
3
4 #include "BaseService.h"
5
6 class BeepService : public BaseService {
7 public :
8     BeepService(LPCTSTR szServiceName)
9         :BaseService(szServiceName)
10         ,m_bPaused(false )
11         ,m_bRunning(false ) {}
12
13     virtual void OnStop() { m_bRunning = false ; }
14     virtual void OnPause() { m_bPaused = true ; }
15     virtual void OnContinue() { m_bPaused = false ; }
16     virtual void Run() {
17         m_bRunning = true ;
18         while (m_bRunning) {
19             if (! m_bPaused)
20                 Beep(800, 800 );
21             Sleep(2000 );
22         }
23     }
24 private :
25     volatile bool m_bPaused;
26     volatile bool m_bRunning;
27 };
28
29 #endif/*BEEP_SERVICE_H*/

通常来说只须要Override上面�?个virtual函数��OK了：
�?em>Run()中进行实际的工作�Q?em>OnStop(),OnPause(),OnContinue()则是��Z��响应Service Control Manager的控制�?br>
test.cpp

1 #include <windows.h>
2 #include <tchar.h>
3 #include <stdio.h>
4 #include "BeepService.h"
5
6 int main(int argc, char * argv[]) {
7
8     BeepService beepService(_T("BeepService" ));
9     if (! beepService.ParseStandardArgs(argc, argv)) {
10         if (beepService.IsInstalled()) {
11             if (! beepService.Start())
12                 printf("The service can not run from command line.\n" );
13         } else {
14             printf("The service is not installed, "
15                 "use \"%s -i\" to install.\n", argv[0 ]);
16         }
17     }
18     return 0 ;
19 }

假设�~�译后生成的exe文�g为beep.exe�Q�则在命令行中可以如下��用：
(1). beep -i 安装service(安装以后�pȝ��q�行时会自动启动)
(2). beep -u 卸蝲service(如果service正在�q�行�Q�则先停止service再卸�?
BaseServiced 的ParseStandardArgs正是用来解析上述两个命��o�?br>
2. ServiceCtrl
虽然Windows自带的Service Control Manager可以控制服务�E�序�Q�但是很多时候我们都需要用代码控制�Q�这��q��到ServiceCtrl�c�，该类的接口如下：
ServiceCtrl.h

1 #ifndef SERVICE_CTRL_H
2 #define SERVICE_CTRL_H
3
4 class ServiceCtrl {
5 public :
6     ServiceCtrl(LPCTSTR szServiceName);
7     ~ ServiceCtrl();
8     bool Start();
9     bool Pause();
10     bool Continue();
11     bool Stop();
12     bool Interrogate();
13     bool UserControl(DWORD dwControl);
14     DWORD State() const ;
15     ...
16 };
17
18 #endif/*SERVICE_CTRL_H*/

接口比较直观没什么好说的�Q�看下面的示例代码：
test.cpp

1 #include <windows.h>
2 #include <tchar.h>
3 #include <stdio.h>
4 #include <exception>
5 #include "BeepService.h"
6 #include "ServiceCtrl.h"
7
8 int main(int argc, char * argv[]) {
9
10     try {
11         ServiceCtrl servCtrl(_T("BeepService" ));
12         if (servCtrl.State() != SERVICE_STOPPED) {
13             printf("Service already started.\n" );
14         } else {
15             servCtrl.Start();
16             printf("Start.\n" );
17             Sleep(6000 );
18             servCtrl.Pause();
19             printf("Pause.\n" );
20             Sleep(6000 );
21             servCtrl.Continue();
22             printf("Continue.\n" );
23             Sleep(6000 );
24             servCtrl.Stop();
25             printf("Stop.\n" );
26         }
27     } catch (std::exception & e) {
28         printf("%s\n" , e.what());
29     }
30     return 0 ;
31 }

源代码：点击下蝲

蚂蚁�l�结�?/a> 2007-09-24 13:01 发表评论

MD5��法的C++实现

Tue, 11 Sep 2007 04:20:00 GMT

摘要: 1. Introduction MD5��法是一�U�消息摘要算�?Message Digest Algorithm)�Q�此��法以�Q意长度的信息(message)作�ؓ输入�q�行计算�Q��生一�?28-bit(16-byte)的指�UҎ��报文摘要(fingerprint or message digest)。两个不同的message产生相同message digest的几率相当小�Q�从一个给定的message ... 阅读全文

蚂蚁�l�结�?/a> 2007-09-11 12:20 发表评论

非完��C++ Singleton实现[2]

Fri, 07 Sep 2007 15:22:00 GMT

4.解决多线�E�问�?br />上一��实现的Singleton只能在单�U�程环境中��用，在多�U�程环境中会出现很多问题�Q�看Instance()实现代码�Q?br />

1 static Singleton& Instance() {
2     if (0 == _instance) { //1
3         _instance = new Singleton(); //2
4         atexit(Destroy);
5     }
6     return *_instance; //3
7 }

考虑如下情况�Q�线�E�一调用Instance()�Q�进�?/1�Q? == _instance �q�回true�Q�线�E�一于是�q�入//2。这时候线�E�一被挂��P��U�程二开始执行，�U�程二调用Instance()�Q�进�?/1�Q�发�? == _instance 仍然�q�回true�Q�线�E�二于是也进�?/2�Q�线�E�二�l�箋执行�?/3直到�q�回。这时候线�E�一被唤醒，�l�箋�?/2开始执行，�q�将会覆盖线�E�二创徏的_instance�Q�线�E�一�l�箋执行�?/3直到�q�回...

解决�Ҏ��很简单，引入相关同步对象(synchronization object)��p��了，例如在win32�q�_��下可以如下实玎ͼ�
synobj.h

1 #ifndef SYNOBJ_H
2 #define SYNOBJ_H
3
4 #include <windows.h>
5
6 #define CLASS_UNCOPYABLE(classname) \
7     private: \
8     classname(const classname&); \
9     classname& operator=(const classname&);
10
11 class Mutex {
12     CLASS_UNCOPYABLE(Mutex)
13 public:
14     Mutex() :_cs() { InitializeCriticalSection(&_cs); }
15     ~Mutex() { DeleteCriticalSection(&_cs); }
16     void lock() { EnterCriticalSection(&_cs); }
17     void unlock() { LeaveCriticalSection(&_cs); }
18 private:
19     CRITICAL_SECTION _cs;
20 };
21
22 class Lock {
23     CLASS_UNCOPYABLE(Lock)
24 public:
25     explicit Lock(Mutex& cs) :_cs(cs) { _cs.lock(); }
26     ~Lock() { _cs.unlock(); }
27 private:
28     Mutex& _cs;
29 };
30
31 #endif/*SYNOBJ_H*/

有了同步对象很容易就能够写出如下代码�Q?br />singleton.h

1 #ifndef SINGLETON_H
2 #define SINGLETON_H
3
4 #include "synobj.h"
5
6 class Singleton {
7 public:
8     static Singleton& Instance() { // Unique point of access
9         Lock lock(_mutex);
10         if (0 == _instance) {
11             _instance = new Singleton();
12             atexit(Destroy); // Register Destroy function
13         }
14         return *_instance;
15     }
16     void DoSomething(){}
17 private:
18     static void Destroy() { // Destroy the only instance
19         if ( _instance != 0 ) {
20             delete _instance;
21             _instance = 0;
22         }
23     }
24     Singleton(){} // Prevent clients from creating a new Singleton
25     ~Singleton(){} // Prevent clients from deleting a Singleton
26     Singleton(const Singleton&); // Prevent clients from copying a Singleton
27     Singleton& operator=(const Singleton&);
28 private:
29     static Mutex _mutex;
30     static Singleton *_instance; // The one and only instance
31 };
32
33 #endif/*SINGLETON_H*/

singleton.cpp

1 #include "singleton.h"
2
3 Mutex Singleton::_mutex;
4 Singleton* Singleton::_instance = 0;

现在的Singleton虽然多线�E�安全，性能却受��C��影响。从Instance()中可以看刎ͼ�实际上仅仅当0 == _instance为true时才需要Lock。你很容易就写出如下代码�Q?br />

1 static Singleton& Instance() {
2     if (0 == _instance) {
3         Lock lock(_mutex);
4         _instance = new Singleton();
5         atexit(Destroy);
6     }
7     return *_instance;
8 }

但是�q�样�q�是会��生竞争条�?race condition)�Q�一�U�广��Z�h知的做法是��用所谓的Double-Checked Locking�Q?br />

1 static Singleton& Instance() {
2     if (0 == _instance) {
3         Lock lock(_mutex);
4         if (0 == _instance) {
5             _instance = new Singleton();
6             atexit(Destroy);
7         }
8     }
9     return *_instance;
10 }

Double-Checked Locking机制看�v来像是一个完��的解决�Ҏ��Q�但是在某些条�g下仍然不行。简单的��_��~�译器�ؓ了效率可能会重排指��o的执行顺�?compiler-based reorderings)。看�q�一行代码：

_instance = new Singleton();

在编译器未优化的情况下顺序如下：
1.new operator分配适当的内存；
2.在分配的内存上构造Singleton对象�Q?br />3.内存地址赋值给_instance�?/span>

但是当编译器优化后执行顺序可能如下：
1.new operator分配适当的内存；
2.内存地址赋值给_instance�Q?br />3.在分配的内存上构造Singleton对象�?/span>

当编译器优化后，如果�U�程一执行�?后被挂�v。线�E�二开始执行�ƈ发现0 == _instance为false�Q�于是直接return�Q�而这时Singleton对象可能�q�未构造完成，后果...

上面说的�q�只是单处理器的情况�Q�在多处理器(multiprocessors)的情况下�Q�超�U�程技术必然会混合执行指��o�Q�指令的执行��序更无法保障。关�?span style="COLOR: #333399">Double-Checked Locking的更详细的文章，��L��Q?br />The "Double-Checked Locking is Broken" Declaration

5.使用volatile关键�?br />��Z��说明问题�Q�请先考虑如下代码�Q?br />

1 class MyThread : public Thread {
2 public:
3     virtual void run() {
4         while (!_stopped) {
5             //do something
6         }
7     }
8     void stop() {
9         _stopped = true;
10     }
11 private:
12     bool _stopped;
13 };
14
15 ...
16
17 MyThread thread;
18 thread.start();

上面用thread.start()开启了一个线�E�，该线�E�在while循环中检��bool标记_stopped�Q�看是否该��l�执行。如果想要结束这个线�E�，调用thread.stop()应该没问题。但是需要注意的是编译器很有可能对_stopped的存取进行优化。如果编译器发现_stopped被频�J�存�?_stopped在while循环�?�Q�编译器可能会考虑��_stopped�~�存到寄存器中，以后_stopped��会直接从寄存器存取。这时候如果某个线�E�调用了thread.stop()�Q�对_stopped的修改将不会反映到寄存器中，thread��会永远循环下去...

��Z��防止�~�译器优化，用volatile关键字就OK了，volatile跟const的用法几乎一��P��能用const的地方也都能用volatile。对Singleton来说�Q�修改如下两处即可：

1 //singleton.h�?/span>
2 static Singleton *_instance;
3 //改�ؓ
4 static Singleton * volatile _instance;
5
6 //singleton.cpp�?/span>
7 Singleton* Singleton::_instance = 0;
8 //改�ؓ
9 Singleton* volatile Singleton::_instance = 0;

6.��Singleton泛化为模�?br />singleton.h

1 #ifndef SINGLETON_H
2 #define SINGLETON_H
3
4 #include "synobj.h"
5
6 template<class T>
7 class Singleton {
8     CLASS_UNCOPYABLE(Singleton)
9 public:
10     static T& Instance() { // Unique point of access
11         if (0 == _instance) {
12             Lock lock(_mutex);
13             if (0 == _instance) {
14                 _instance = new T();
15                 atexit(Destroy);
16             }
17         }
18         return *_instance;
19     }
20 protected:
21     Singleton(){}
22     ~Singleton(){}
23 private:
24     static void Destroy() { // Destroy the only instance
25         if ( _instance != 0 ) {
26             delete _instance;
27             _instance = 0;
28         }
29     }
30     static Mutex _mutex;
31     static T * volatile _instance; // The one and only instance
32 };
33
34 template<class T>
35 Mutex Singleton<T>::_mutex;
36
37 template<class T>
38 T * volatile Singleton<T>::_instance = 0;
39
40 #endif/*SINGLETON_H*/

��试代码�Q?br />test.cpp

1 #include "singleton.h"
2
3 class A : public Singleton<A> {
4     friend class Singleton<A>;
5 protected:
6     A(){}
7     ~A(){}
8 public:
9     void DoSomething(){}
10 };
11
12 int main() {
13
14     A &a = A::Instance();
15     a.DoSomething();
16
17     return 0;
18 }

7.Singleton的析构问�?/strong>
到此Singleton已经��比较完善了�Q�但是依然算不上完美�Q�因为到现在只是解决了多�U�程问题�Q�加入了模板支持�Q�对�?span style="COLOR: #333399">KDL problem(The Dead Reference Problem)依然没法解决�Q�可以说在实现Singleton模式�Ӟ��最大的问题��是多个有依赖关�pȝ��Singleton的析构顺�?/span>。虽�?em style="COLOR: #333399">Modern C++ Design中给��Z��解决�Ҏ��Q�但�?span style="COLOR: #333399">Loki的实现太�q�复杂，在此��׃��详细说明了，有兴��的可以看看Modern C++ Design�Q�当然了�Q?span style="COLOR: #333399">Loki库中用策略模式实现的Singleton也很不错�Q?br />

蚂蚁�l�结�?/a> 2007-09-07 23:22 发表评论

非完��C++ Singleton实现[1]

Fri, 07 Sep 2007 06:49:00 GMT

Singleton模式是一�U�非常简单的设计模式�Q�这�U�模式很常用也很�Ҏ��被滥用。当你设计应用程序的时候，�l�常会遇到某些对象在整个�E�序的生命周期应该仅有一个实例的情况�Q�比�?span style="COLOR: #333399">File System�Q�Graphic System�Q�Logging Utility�Q�这时候就可以用到Singleton模式。Singleton模式�?span style="COLOR: #333399">GOF中描�q�如下：

        Ensure a class only has one instance, and provide a global point of access to it.

Singleton模式的定义很��单，实现也有N多种�Q�但是却很难扑ֈ�一个称得上“完美”的。实��C��个完��的Singleton比想象中要难的多�Q�下面探索性的来实��C��个非完美的�?br>
1.典型实现
在C++中，Singleton模式的典型实现如下：

1 // Header file Singleton.h
2 class Singleton {
3 public :
4     static Singleton& Instance() { // Unique point of access
5         if (0 == _instance)
6             _instance = new Singleton();
7         return * _instance;
8     }
9     void DoSomething();
10 private :
11     Singleton(); // Prevent clients from creating a new Singleton
12     ~Singleton(); // Prevent clients from deleting a Singleton
13     Singleton(const Singleton&); // Prevent clients from copying a Singleton
14     Singleton& operator=(const Singleton& );
15 private :
16     static Singleton *_instance; // The one and only instance
17 };
18
19 // Implementation file Singleton.cpp
20 Singleton* Singleton::_instance = 0;

通过��Singleton的构造函数设为private可以��止客户代码直接创徏Singleton对象�Q�除此之外，Singleton的copy constructor和copy assignment operator都�ؓprivate且仅有声明没有实玎ͼ��止了客户代码拷贝Singleton对象。唯一可以创徏Singleton对象的是Singleton自己的静态成员函数Instance�Q�这样就在编译器保证了Singleton实例的唯一性。上面这些是在C++中实现Singleton模式最基本的要炏V�?br>
Instance�Ҏ��保证只有在第一�ơ调用时才会生成Singleton对象�Q�以后的调用只是��单返回唯一的已存在的实例。Instance�Ҏ��实际上实现的�?span style="COLOR: #333399">懒惰初始�?lazy initialize)�Q?/em>如果�E�序中根本没有用到Singleton对象�Q�也��根本不会��生Singleton的实例，�q�在Singleton对象很少使用且创建Singleton对象开销比较大的情况下特别有用�?/p>
客户代码现在可以�q�样使用Singleton�Q?/p>
1 Singleton &s = Singleton::Instance();
2 s.DoSomething();

�q�需要说明的是Singleton的析构函敎ͼ�析构函数也�ؓprivate可以��止客户写出如下代码。如果某个客户写��Z��如下代码�Q�随后的对Singleton的访问就会导致�ؓ定义行�ؓ�Q�因为Singleton对象已经不存在�?br>

1 Singleton *p = & Singleton::Instance();
2 delete p;

2.引入smart pointer
上面的实现算是一个好的实现吗�Q�当然不是，或许�q�一个正��的实现都算不上。如果你惛_��合，当然没问题，上面的代码大多数情况下可以工作的很好。也�怽�已经注意��C��一些问题，比如说在上面的代码中只有new没有delete。是的，你说会发生memory leak对吧�Q�其实memory leak都不是主要的问题�Q�所有的��C��操作�pȝ��在进�E�结束的时候都会对内存很好的进行回收。比memory leak更值得让�h担忧的是resource leak�Q�如果Singleton在构造函��C��h��了某些资源：�|�络�q�接�Q�文件句柄，数据库连接等。这些资源将得不到释放�?br>
唯一修正resource leak的方法就是在�E�序�l�束的时候delete _instance。当然了�Q�用smart pointer再好不过�Q�在�q�里用auto_ptr��可以满��需要了(如果你还不知道smart_ptr是什么，��q��旉��熟悉C++标准库吧)�Q�修改后的代码如下：

1 // Header file Singleton.h
2 class Singleton {
3 public :
4     static Singleton& Instance() { // Unique point of access
5         if (0 == _instance.get())
6             _instance.reset(new Singleton());
7         return * (_instance.get());
8     }
9     void DoSomething(){}
10 private :
11     Singleton(){} // Prevent clients from creating a new Singleton
12     ~Singleton(){} // Prevent clients from deleting a Singleton
13     Singleton(const Singleton&); // Prevent clients from copying a Singleton
14     Singleton& operator=(const Singleton& );
15 private :
16     friend auto_ptr<Singleton> ;
17     static auto_ptr<Singleton> _instance; // The one and only instance
18 };
19
20 // Implementation file Singleton.cpp
21 auto_ptr<Singleton> Singleton::_instance;

3.用atexit替换smart pointer
C++�q�没有规定不�?span style="COLOR: #333399">�~�译单元(translation unit�Q�简单说��是一个可�~�译的cpp文�g)中static对象的初始化��序。如果一个程序中有多个Singleton对象�Q�那么这些Singleton对象的析构顺序也��是��L��的。很昄��Q�当多个Singleton对象有依赖关�p�L��Q�smart pointer�Ҏ��无法保证Singleton的析构顺序�?br>
msdn中对atexit描述如下�Q?/p>
The atexit function is passed the address of a function (func) to be called when the program terminates normally. Successive calls to atexit create a register of functions that are executed in last-in, first-out (LIFO) order. The functions passed to atexit cannot take parameters. atexit use the heap to hold the register of functions. Thus, the number of functions that can be registered is limited only by heap memory.

需要说明的是atexit�q�不比smart pointer好多��，LIFO的保证对于有复杂依赖关系的多个Singleton依然束手无力�Q�但是用atexit替换smart pointer却是必须的，它是设计完美Singleton的基��?br>

#如果你疑惑atexit��Z��么还是不行，误��虑下面的情况：
NOTE�Q�下面的情况�?em>Modern C++ Design中叫�?em style="COLOR: #333399">KDL(Keyboard,Display,Log)problem�?br>
某个�E�序中��用了如下3个Singleton�Q?span style="COLOR: #333399">Keyboard�Q?span style="COLOR: #333399">Display�Q?span style="COLOR: #333399">Log�?span style="COLOR: #333399">Keyboard�?span style="COLOR: #333399">Display分别对应于计��机的键盘和昄��器，Log用来记录错误信息。假讑ֽ�Keyboard�?span style="COLOR: #333399">Display的构造函数和析构函数出现错误时会调用Log记录错误信息�Q��ƈ且构造和析构��D��的�Q何错误都会终止程序�?br>
在程序启动时�Q�如�?span style="COLOR: #333399">Keyboard构造成功，Display构造失败，很显然在Display的构造函��C��会构�?span style="COLOR: #333399">Log而且��p�|信息会被Log记录�Q�根据假设这时候程序准备退出，atexit注册的函数将会按LIFO的顺序被调用。因�?span style="COLOR: #333399">Keyboard先于Log构造，所�?span style="COLOR: #333399">Log先于Keyboard析构�Q�但是当�׃��某种原因Keyboard在析构时��p�|�Q�想要调�?span style="COLOR: #333399">Log记录错误信息�Ӟ��Log早已被销毁，则Log::Instance()��会��D��未定义行为�?br>

#atexit的严重问题：
从上面的例子可以看出�Q�atexit和smart pointer相比仅仅是有LIFO的保证而已�Q�这��L��保证貌似也不怎么有效�Q�因为atexit跟smart pointer一样也无法解决KDL probleam�?br>
atexit�׃��LIFO带来了另外的问题�Q�看下面的代码：

1 #include <cstdlib>
2 void Bar() {
3     ...
4 }
5 void Foo() {
6     std::atexit(Bar);
7 }
8 int main() {
9     std::atexit(Foo);
10     return 0 ;
11 }

上面的小�D�代码用atexit注册了Foo�Q�Foo调用了std::atexit(Bar)。当�E�序退出时�Q�根据atexit的LIFO保证�Q�Bar在Foo之后注册�Q�因此Bar应该在Foo之前调用�Q�但是当Bar注册的时候Foo已经调用了，Bar�Ҏ��没有机会能够在Foo之前调用。这明显自相矛盾对吧�Q�没办法�Q�C++标准好像忽视了这一点，因此如果�c�M��代码被调用，肯定不会有什么好的结果，好一�Ҏ��resource leak�Q�差一点估计程序就崩溃了！�Q�！

atexit的这个问题跟Singleton有关�p�d��Q�当然有�Q�如果在一个Singleton的析构函��C��调用atexit��׃��出现上述问题。即�?span style="COLOR: #333399">KDL problem中，如果Keyboard�?span style="COLOR: #333399">Display都构造成功，�?span style="COLOR: #333399">Keyboard�?span style="COLOR: #333399">Display��L��一个析构失败时�Q?span style="COLOR: #333399">Keyboard�?span style="COLOR: #333399">Display在析构函��C��会构�?span style="COLOR: #333399">Log�Q?span style="COLOR: #333399">Log的构造函��C��间接调用atexit。oops!!!�Q�可怕的未定义行为�?br>
看到�q�里你一定对atexit相当失望�Q�貌似它带来的好处多于坏处。但是请你相信，如果适当设计�Q�atexit在后面的Singleton攚w��中会�v到很重要的作用�?br>
用atexit后的代码�Q?/p>
1 // Header file Singleton.h
2 class Singleton {
3 public :
4     static Singleton& Instance() { // Unique point of access
5         if (0 == _instance) {
6             _instance = new Singleton();
7             atexit(Destroy); // Register Destroy function
8         }
9         return * _instance;
10     }
11     void DoSomething(){}
12 private :
13     static void Destroy() { // Destroy the only instance
14         if ( _instance != 0 ) {
15             delete _instance;
16             _instance = 0 ;
17         }
18     }
19     Singleton(){} // Prevent clients from creating a new Singleton
20     ~Singleton(){} // Prevent clients from deleting a Singleton
21     Singleton(const Singleton&); // Prevent clients from copying a Singleton
22     Singleton& operator=(const Singleton& );
23 private :
24     static Singleton *_instance; // The one and only instance
25 };
26
27 // Implementation file Singleton.cpp
28 Singleton* Singleton::_instance = 0;

你有没有仔细考虑�q�Destroy中的_instance = 0;�q�一行代码，上述代码实际上实现的�?em style="COLOR: #333399">不死鸟模�?The Phoenix Singleton)�Q?/em>所谓不死鸟�Q�就跟一辉一样可以死而复生。上面的代码可以解决本文最早提出的KDL problem�Q�即如果Keyboard析构��p�|�Q�虽�?span style="COLOR: #333399">Log已经析构�Q�但是由于Destroy中的_instance = 0;�q�一行代码，Log::Instance()��会创徏一个新�?span style="COLOR: #333399">Log对象�Q�程序将会表现良好。当然了�Q?span style="COLOR: #993366">Phoenix Singleton仅能用于无状态的Singleton�Q�如�?span style="COLOR: #333399">Log需要保存某些状态，Phoenix Singleton也不会带来�Q何好处。你当然可以用某些方法维�?span style="COLOR: #993366">Phoenix Singleton的状态，但是在做之前先想想看是否值得�Q�维持状态可能会使Singleton变得特别复杂�?br>
上面�?span style="COLOR: #993366">Phoenix Singleton已经可以满��大部分需要，如果你的Singleton没有涉及到多�U�程�Q�多个Singleton之间也没有依赖关�p�，你大可以攑ֿ�使用。但是如果你用到多线�E�，或者你的Singleton关系�?span style="COLOR: #333399">KDL般复杂，或者你觉得�Ҏ��一个Singleton都敲同样的代码让你厌烦。在后面几篇会有一�?span style="COLOR: #993366">多线�E�安�?/span>的，能够解决多个Singleton依赖关系的，��Z��模板的Singleton实现�?br>

蚂蚁�l�结�?/a> 2007-09-07 14:49 发表评论

从Win32 API��装Thread�c�[2]

Fri, 31 Aug 2007 03:58:00 GMT
在上一��中介绍了创建Thread的两�U�方法：从Thread�cȝ��承或者实现Runnable接口。有时候这�q�不是特别方便，我们需要的是更灉|��的方法，比如像boost库中的Thread一样可以用普通函数和函数对象
(functor and function object)作�ؓ构造函数参数。如果你熟悉STL�Q�你应该熟悉bind1st和bind2nd�q�两个函数配接器(function adapter)�Q�bind1st和bind2nd可以��一个二元函�?binary function)转换成一元函�?unary function)。�ؓ了��Thread�c�能够用普通函数和函数对象作�ؓ参数�Q�我们需要一个bind��一元函数�{换成无参函数�Q?br />bind.h
1 #ifndef BIND_H
2 #define BIND_H
3
4 template <class _Result>
5 struct trivial_function {
6     typedef _Result result_type;
7 };
8
9 template <class _Operation>
10 class binder : public trivial_function<typename _Operation::result_type> {
11 public:
12     binder(const _Operation& x, const typename _Operation::argument_type& y)
13         :op(x), value(y) {}
14     typename _Operation::result_type operator()() const {
15         return op(value);
16     }
17 protected:
18     _Operation op;
19     typename _Operation::argument_type value;
20 };
21
22 template <class _Operation, class _Tp>
23 inline binder<_Operation>
24 bind(const _Operation& __fn, const _Tp& __x)
25 {
26     typedef typename _Operation::argument_type _Arg_type;
27     return binder<_Operation>(__fn, _Arg_type(__x));
28 }
29
30 #endif/*BIND_H*/

有了bind我们�q�需要修改Thread�cȝ��构造函敎ͼ�昄��我们必须��构造函数声明�ؓ成员模板(�q�有一�U�方法也可以辑ֈ�同样的目的，��是把Thread�c�d��明�ؓ模板�Q�但是这��L��设计好像不太�?�Q�这��h��能够让Thread�cȝ��构造函数可以接受各�U�类型的参数�Q�修改后的构造函数应该能够��用如下三�U�类型的参数�Q?br />1.Runnable *
2.no argument function
3.no argument functor
下面是修改后的头文�g�Q?br />runnable.h
1 #ifndef RUNNABLE_H
2 #define RUNNABLE_H
3
4 struct Runnable {
5     virtual void run() = 0;
6     virtual ~Runnable() {}
7 };
8
9 template <class T>
10 class RunnableFunctor : public Runnable {
11 public:
12     RunnableFunctor(const T& f) :_func(f) {}
13     virtual void run() { _func(); }
14 private:
15     T _func;
16 };
17
18 //base template for no argument functor
19 template <class T>
20 struct FuncImpl {
21     static Runnable* transfer(const T& t) {
22         return new RunnableFunctor<T>(t);
23     }
24 };
25
26 //partial specialization for T*
27 template <class T>
28 struct FuncImpl<T*> {
29     static Runnable* transfer(T* t) {
30         return t;
31     }
32 };
33
34 //partial specialization for no argument function
35 template <class T>
36 struct FuncImpl<T (*)()> {
37     static Runnable* transfer(T (*t)()) {
38         return new RunnableFunctor<T (*)()>(t);
39     }
40 };
41
42 template <class T>
43 inline Runnable* transfer(const T& t) {
44     return FuncImpl<T>::transfer(t);
45 }
46
47 #endif/*RUNNABLE_H*/

thread.h
1 #ifndef THREAD_H
2 #define THREAD_H
3
4 #include <windows.h>
5 #include "bind.h"
6 #include "runnable.h"
7
8 #define CLASS_UNCOPYABLE(classname) \
9     private: \
10     classname(const classname&); \
11     classname& operator=(const classname&);
12
13 class Thread : public Runnable {
14     CLASS_UNCOPYABLE(Thread)
15 public:
16     Thread()
17         :_target(0)
18         ,_handle(0) {
19
20     }
21     template <class T>
22     explicit Thread(const T& op)
23         :_target(transfer(op))
24         ,_handle(0) {
25
26     }
27     virtual ~Thread();
28     virtual void run() {}
29     void start();
30     void join();
31 private:
32     static unsigned __stdcall threadProc(void* param);
33 private:
34     Runnable* _target;
35     HANDLE _handle;
36 };
37
38 #endif/*THREAD_H*/

thread.cpp和前一��的几乎一��P��唯一的不同是��L��了构造函数Thread(Runnable *)�Q�因为现在的构造函数改成了成员模板�Q�实��C��攑֜�thread.h中了。现在的构造函数能够接受各�U�类型的参数�Q�主要归功于模板函数transfer�Q�实��C��码在runnable.h中，主要技巧是用类的偏特化模拟函数模板的偏特化�Q�不明白的请�?a id="_117bf2a46b69_HomePageDays_DaysList_ctl00_DayItem_DayList_ctl01_TitleUrl" href="/ant/archive/2007/08/30/31201.html">��Z��么不要特化函数模�?/a>�?br />
下面是测试代码：
test.cpp
1 #include "thread.h"
2 #include <iostream>
3 #include <functional>
4
5 using namespace std;
6
7 //no argument function
8 void print() {
9     cout << "print" << endl;
10 }
11
12 //unary function
13 void print1(int n) {
14     cout << "print1" << endl;
15 }
16
17 //binary function
18 void print2(int m, int n) {
19     cout << "print2" << endl;
20 }
21
22
23 //no argument functor
24 struct PrintFunctor {
25     void operator()() const {
26         cout << "PrintFunctor" << endl;
27     }
28 };
29
30 //unary functor
31 struct PrintFunctor1 : public unary_function<int, void> {
32     void operator()(int n) const {
33         cout << "PrintFunctor1" << endl;
34     }
35 };
36
37 //binary functor
38 struct PrintFunctor2 : public binary_function<int, int, void> {
39     void operator()(int m, int n) const {
40         cout << "PrintFunctor2" << endl;
41     }
42 };
43
44 int main() {
45
46     //construct Thread with no argument function
47     Thread thread1(&print);
48     thread1.start();
49
50     //construct Thread with unary function
51     Thread thread2(bind(ptr_fun(print1), 5));
52     thread2.start();
53
54     //construct Thread with binary function
55     Thread thread3(bind(bind1st(ptr_fun(print2), 1), 2));
56     thread3.start();
57
58
59     //construct Thread with no argument functor
60     Thread thread4((PrintFunctor()));
61     thread4.start();
62
63     //construct Thread with unary functor
64     Thread thread5(bind(PrintFunctor1(), 5));
65     thread5.start();
66
67     //construct Thread with binary functor
68     Thread thread6(bind(bind1st(PrintFunctor2(), 1), 2));
69     thread6.start();
70
71     thread1.join();
72     thread2.join();
73     thread3.join();
74     thread4.join();
75     thread5.join();
76     thread6.join();
77
78     return 0;
79 }

当然了，上面的�ƈ不是全部�Q�修改后的Thread�c�M��仅能够��用原先的从Thread�cȝ��承或者实现Runnable接口的方法，�q�可以��用�Q何无参函数或无参函数对象。除了test.cpp里示范的�Q�你甚至可以用bind,bind1st,bind2st,mem_fun,mem_fun_ref的组合来用某个类的成员函��C��为参敎ͼ��h��强的灵�z�L��?br />
目前实现的这些都是Thread�c�L��基本的功能，其他功能如设�|�线�E�优先��Q�挂��h��恢复�U�程�Q�异常处理等具体实现都比较简单，�q�这里就不一一实现了�?
源代码下载：点击下蝲

蚂蚁�l�结�?/a> 2007-08-31 11:58 发表评论

C++&Win32写的�I�当接龙

Thu, 30 Aug 2007 13:37:00 GMT
上学期做评��设计�Q�老师让我做windows自带�?span style="COLOR: #993300">�I�当接龙游戏�Q�写了一个礼拜，完全仿windows的呵��c�?br>不过也不全一��P��有一些细节一直没有时间弄�Q�没办法最�q�比较懒...

与windows下的相比�Q�我做的�q�个加入�?span style="COLOR: #993300">AI(快捷键F6)�Q�可以开�?span style="COLOR: #993300">�Uȝ��提示(快捷键F7)�Q�不�q?span style="COLOR: #993300">撤销一直没有做�Q�可能哪天突然想做了会加上去。另外改�q�了废牌回收��法�Q�非法移牌的提示直接��L��了，�q�有一些小的细节作了改�q��?br>感兴��的可以下蝲�Q?a title=点击下蝲 href="http://www.shnenglu.com/Files/ant/Freecell.rar">点击下蝲
源代码下载：点击下蝲
��Z��发几张截图：

蚂蚁�l�结�?/a> 2007-08-30 21:37 发表评论

Thu, 30 Aug 2007 05:55:00 GMT

Overloading vs. Specialization

在C++中有class templates �?em>function templates�Q�这两种模版有很多区别，最重要的区别就是重�?overloading)�Q?br />普通的C++�c�M��能重载，当然�c�L��版也不能重蝲�Q�相反，普通函数可以重载，函数模版也能重蝲。这再正�怸��q�，看下面的代码�Q?/p>
1 // Example 1: Class vs. function template, and overloading
2 //
3
4 // A class template
5 template<class T> class X { /*...*/ };      // (a)
6
7 // A function template with two overloads
8 template<class T> void f( T );              // (b)
9 template<class T> void f( int, T, double ); // (c)
10

像上面未特化的模杉K��常叫做base templates。当�Ӟ��base templates能够被特化，在特化这一点上
class templates �?em>function templates有很大的区别�Q�一�?em>class template 能够�?em>partially specialized and/or
fully specialized�Q�一�?em>function template只能�?em>fully specialized�Q�但是由�?em>function templates能够重蝲我们可以通过重蝲来实现和partially specialized 相当的功能。下面的代码说明了这些区别：

1 // Example 1, continued: Specializing templates
2 //
3
4 // A partial specialization of (a) for pointer types
5 template<class T> class X<T*> { /*...*/ };
6
7 // A full specialization of (a) for int
8 template<> class X<int> { /*...*/ };
9
10 // A separate base template that overloads (b) and (c)
11 // -- NOT a partial specialization of (b), because
12 // there's no such thing as a partial specialization
13 // of a function template!
14 template<class T> void f( T* );             // (d)
15
16 // A full specialization of (b) for int
17 template<> void f<int>( int );              // (e)
18
19 // A plain old function that happens to overload with
20 // (b), (c), and (d) -- but not (e), which we'll
21 // discuss in a moment
22 void f( double );                           // (f)
23

�Ҏ��函数重蝲解析规则�Q?/p>
1 // Example 1, continued: Overload resolution
2 //
3 bool b;
4 int i;
5 double d;
6
7 f( b );        // calls (b) with T = bool
8 f( i, 42, d ); // calls (c) with T = int
9 f( &i );       // calls (d) with T = int
10 f( i );        // calls (e)
11 f( d );        // calls (f)

上面说的�q�些其实都是很简单的情况�Q�大多数人很�Ҏ��p��明白�Q�下面的才是�Ҏ��让�h弄�؜的：

1.考虑如下代码�Q?/p>
1 // Example 2: Explicit specialization
2 //
3 template<class T> // (a) a base template
4 void f( T );
5
6 template<class T> // (b) a second base template, overloads (a)
7 void f( T* );     //      (function templates can't be partially
8                   //     specialized; they overload instead)
9
10 template<>        // (c) explicit specialization of (b)
11 void f<>(int* );
12
13 // ...
14
15 int * p;
16 f( p );           // calls (c)

最后一行的�l�果像大多数人所期望的一��P��问题是：��Z��么期望是�q�个�l�果�Q?br />如果你期望的原因是错误的�Q�接下来的一定会让你好奇。也�怽�会说�Q?我�ؓint*写了一个特化版本，f(p)当然会调�?span style="COLOR: #3366ff">c"�Q�不�q�的是，�q�正是错误的原因!!!

2.再考虑下面的代码：

1 // Example 3
2 //
3 template<class T> // (a) same old base template as before
4 void f( T );
5
6 template<>        // (c) explicit specialization, this time of (a)
7 void f<>(int* );
8
9 template<class T> // (b) a second base template, overloads (a)
10 void f( T* );
11
12 // ...
13
14 int * p;
15 f( p );           // calls (b)! overload resolution ignores
16                   // specializations and operates on the base
17                   // function templates only

如果�q�个�l�果让你感到惊奇�Q�那��对了！很多人都会感到惊奇！
理解�q�个的关键是�Q?em style="COLOR: #993300">Specializations don't overload,only the base templates overload.

重蝲解析仅仅选择base template(或者nontemplate function�Q�如果有的话)�Q�只有当�~�译器已�l�决定了哪个
base template��会被选择�Q�编译器才会�l�箋往下寻��N��合的特化版本，如果扑ֈ�了就使用那个特化版本�?br />
最后，应当避免特化函数模板�Q�也要避免重载函数模�?nontemplate function的重载当然没问题)。如果一定要�q�样�Q�可以��用如下方法模拟函数模板的偏特化：

1 //base template class,
2 template <class T>
3 struct FuncImpl {
4     //users, go ahead and specialize this
5     static int apply(const T & t) {
6         return 0 ;
7     }
8 };
9
10 //partial specialazation for int
11 template <>
12 struct FuncImpl<int> {
13     static int apply(int t) {
14         return 1 ;
15     }
16 };
17
18 //partial specialazation for T*
19 template <class T>
20     struct FuncImpl<T *> {
21     static int apply(T * t) {
22         return 2 ;
23     }
24 };
25
26 //users, don't touch this!
27 template <class T>
28 int func(const T & t) {
29     return FuncImpl<T> ::apply(t);
30 }
31
32 int i = 10 , r;
33 r = func('c'); //r = 0
34 r = func(8); //r = 1
35 r = func(&i); //r = 2

蚂蚁�l�结�?/a> 2007-08-30 13:55 发表评论

从Win32 API��装Thread�c�[1]

Thu, 30 Aug 2007 02:18:00 GMT

前几天在学Windows多线�E�程序设计，发现Win32 API用�v来确实不怎么方便�Q�特别是对于C++�E�序员。于是实��C��一个简单的��装�Q�技术含量当然不高，不过用�v来还是比较方便的。如果你熟悉Java�Q�你会发现这个实现有点像Java的Thread�Q�在Java中有两种�Ҏ��可以创徏一个Thread�Q?br />
1.从Thread�cȝ��承�ƈ实现run�Ҏ��Q?/p>
1 class MyThread extends Thread {
2     public void run() {
3         ...
4     }
5 };
6
7 //开启线�E?/span>
8 MyThread thread = new MyThread;
9 thread.start();

2.声明一个类实现Runnable接口�q�实现run�Ҏ��Q?/p>
1 class MyRunnable implements Runnable {
2     public void run() {
3         ...
4     }
5 };
6
7 // 开启线�E��?/span>
8 MyThread thread = new MyThread(new MyRunnable);
9 thread.start();

具体实现
Java的实现方式还��优雅，我们也可以在C++中模拟，�׃��幅所限，在这里我们只��x��基本功能的实玎ͼ�
thread.h
1 #ifndef THREAD_H
2 #define THREAD_H
3
4 #include <windows.h>
5
6 #define CLASS_UNCOPYABLE(classname) \
7     private: \
8     classname(const classname&); \
9     classname& operator=(const classname&);
10
11 struct Runnable {
12     virtual void run() = 0;
13     virtual ~Runnable() {}
14 };
15
16 class Thread : public Runnable {
17     CLASS_UNCOPYABLE(Thread)
18 public:
19     explicit Thread(Runnable* target = 0);
20     virtual ~Thread();
21     virtual void run() {}
22     void start();
23     void join();
24 private:
25     static unsigned __stdcall threadProc(void* param);
26 private:
27     Runnable* _target;
28     HANDLE _handle;
29 };
30
31 #endif/*THREAD_H*/

在上面的代码中我们先定义一个Runnable�c�，�q��ؓRunnable�c�L��加纯虚函数run�Q�需要特别注意的是Runnable�cȝ��虚析构函敎ͼ��M��惌��成�ؓ基类的class都应该声明析构函��Cؓvirtual�?br />Thread�cȝ��接��承自Runnable�Q�CLASS_UNCOPYABLE(Thread) �q�一行用宏声明Thread�c�M��可拷贝，具体�l�节��L�� 考虑用Macro替换Uncopyable 。start成员函数和Java中的一��P��用来开启一个线�E�，join成员函数用来��d��当前�U�程直到开启的�U�程执行完毕。threadProc作�ؓ静态成员函数用来传递给_beginthreadex�Q�至于�ؓ什么用_beginthreadex代替CreateThread请问Google。初步的实现都比较简单，直接贴上代码�Q?br />thread.cpp
1 #include "thread.h"
2 #include <process.h> // for _beginthreadex
3
4 Thread::Thread(Runnable* target /*= 0*/)
5 :_target(target)
6 ,_handle(0) {
7
8 }
9
10 Thread::~Thread() {
11     if (_handle != 0)
12         CloseHandle(_handle);
13     if (_target != 0)
14         delete _target;
15 }
16
17 void Thread::start() {
18     if (_handle != 0)
19         return;
20     unsigned id;
21     _handle = reinterpret_cast<HANDLE>(
22         _beginthreadex(0, 0, threadProc, this, 0, &id)
23         );
24 }
25
26 void Thread::join() {
27     if(_handle != 0) {
28         WaitForSingleObject(_handle, INFINITE);
29         CloseHandle(_handle);
30         _handle = 0;
31     }
32 }
33
34 unsigned __stdcall Thread::threadProc(void* param) {
35     Thread* p = static_cast<Thread*>(param);
36     if (p->_target != 0)
37         p->_target->run();
38     else
39         p->run();
40     return 0;
41 }

下面是测试代码：
test.cpp
1 #include "thread.h"
2 #include <iostream>
3
4 using namespace std;
5
6 //�W�一�U�方法，从Thread�cȝ��?/span>
7 struct MyThread : public Thread {
8     virtual void run() {
9         for (int i = 0; i < 5; ++i) {
10             cout << "MyThread Running..." << i << endl;
11             Sleep(100);
12         }
13     }
14 };
15
16 //�W�二�U�方法，“实现”Runnable接口
17 struct MyRunnable : public Runnable {
18     virtual void run() {
19         for (int i = 0; i < 5; ++i) {
20             cout << "MyRunnable Running..." << i << endl;
21             Sleep(300);
22         }
23     }
24 };
25
26 int main() {
27
28     MyThread thread1;
29     Thread thread2(new MyRunnable());
30     thread1.start();
31     thread2.start();
32     thread1.join();
33     thread2.join();
34
35     return 0;
36 }

可能的运行结果：
MyThread Running...0
MyRunnable Running...0
MyThread Running...1
MyThread Running...2
MyRunnable Running...1
MyThread Running...3
MyThread Running...4
MyRunnable Running...2
MyRunnable Running...3
MyRunnable Running...4

如果你熟悉boost库，你会知道boost库的Thread构造函数可以接受普通函数和函数对象作�ؓ参数�Q�如果你觉得从Thread�cȝ��承或者实现Runnable接口�q�不够简�z�，下一��会有一个比较好的改�q��?

蚂蚁�l�结�?/a> 2007-08-30 10:18 发表评论

考虑用Macro替换Uncopyable

Mon, 27 Aug 2007 00:11:00 GMT
看过Effective C++的�h都知道，��Z��防止一个class被copying�Q�而且��错误提前到�~�译期，基本有两�U�方法：
1. ��这个类的copy构造函数和copy assignment操作�W�都声明为private而且没有定义。示例代码如下：
1 class SomeClass {
2     ...
3 private:
4     //只有声明
5     SomeClass(const SomeClass&);
6     SomeClass& operator=(const SomeClass&);
7 };

2. 专门设计一个�ؓ了阻止copying动作而设计的base class�Q�这个base class相当��单：
1 Uncopyable {
2 protected: //允许derived对象构造和析构
3     Uncopyable() {}
4     ~Uncopyable() {}
5 private: //��L��copying
6     Uncopyable(const Uncopyable&);
7     Uncopyable& operator=(const Uncopyable&);
8 };

��Z��L��某个对象如SomeClass被copying�Q�我们唯一需要做的就是��承自Uncopyable�Q?br />
1 SomeClass : private Uncopyable {
2     ...
3 };

�W?�U�方案貌似很完美�Q�在大多数情况下也工作的很好�Q�甚至boost库也�q�泛采用�?boost库中的叫noncopyable)。当然了�Q�因为Uncopyable不含��M��数据�Q�符合EBO(empty base class optimization�Q�空白基�c�L��优化)资格�Q�但�׃��它��L��扮演base class�Q�因此有可能��D��多重�l�承�Q�而EBO一般只在单�l�承下才可行�Q�编译器通常不会�Ҏ��多个base class的derived classes施行EBO�?br />
如果你不惛_��致多重��承，不管是从性能上还是书写代码上�Q�比如SomeClass�l�承自某个base class�Q�你可能会写如下代码�Q?br />
1 class SomeClass : public BaseClass, private Uncopyable {
2     ...
3 };

�q�让人很不爽�Q�要是你跟我一��h��Q�你肯定也不会愿意采用第一�U�方案，因�ؓ那意味着你会在每一个不惌��copying的class里都加上那三行代码�?br />
如果用Macro��很��单了�Q�即灉|��又方便：
1 #define CLASS_UNCOPYABLE(classname) \
2     private: \
3     classname(const classname&); \
4     classname& operator=(const classname&);

现在SomeClass只需写成�q�样�Q?br />
1 class SomeClass {
2     CLASS_UNCOPYABLE(SomeClass)
3     ...
4 };

不仅省事而且灉|��Q�！�Q?img src ="http://www.shnenglu.com/ant/aggbug/30908.html" width = "1" height = "1" />

蚂蚁�l�结�?/a> 2007-08-27 08:11 发表评论

青青草国产精品久久久久,免费国产99久久久香蕉,久久高潮一级毛片免费

strlen源码剖析

TEA加密���法的C/C++实现

MD5���法的C++实现

非完���C++ Singleton实现[2]

非完���C++ Singleton实现[1]

从Win32 API���装Thread�c�[2]

C++&Win32写的�I�当接龙

从Win32 API���装Thread�c�[1]

考虑用Macro替换Uncopyable

TEA加密��法的C/C++实现

MD5��法的C++实现

非完��C++ Singleton实现[2]

非完��C++ Singleton实现[1]

从Win32 API��装Thread�c�[2]

从Win32 API��装Thread�c�[1]