C++博客-#ant-随笔分类-C++

腾讯广州招聘手机客户端开发人员

蚂蚁终结者 — Wed, 19 May 2010 14:14:00 GMT

好久没更新日志了，发一则小招聘广告：

    腾讯广州招聘手机客户端开发人员
    基本要求：
    1).1～2年工作经验；
    2).有Symbian/Andriod/iPhone手机客户端开发经验(有Symbian C++开发经验者优先)；

有意向者请联系：peterfan@tencent.com

蚂蚁终结者 2010-05-19 22:14 发表评论

Win32 Service的简单封装

蚂蚁终结者 — Mon, 24 Sep 2007 05:01:00 GMT

前段时间学习Windows程序设计，刚好学到Win32 Service，于是写了两个简单的类：BaseService和ServiceCtrl。虽然功能比较简单，但是也能适用于大多数情况。下面介绍一下简单用法，如果你刚好需要写一些简单的服务程序，这两个类也许能派上用场：

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*/

要实现自己的服务类只需从BaseService继承并且Override相关的virtual函数即可，下面示范一个BeepService类，该服务只是简单地每隔2秒beep一下，为了简单所有代码均放在.h文件中：
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上面的4个virtual函数就OK了：
在Run()中进行实际的工作，OnStop(),OnPause(),OnContinue()则是为了响应Service Control Manager的控制。

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文件为beep.exe，则在命令行中可以如下使用：
(1). beep -i 安装service(安装以后系统运行时会自动启动)
(2). beep -u 卸载service(如果service正在运行，则先停止service再卸载)
BaseServiced 的ParseStandardArgs正是用来解析上述两个命令。

2. ServiceCtrl
虽然Windows自带的Service Control Manager可以控制服务程序，但是很多时候我们都需要用代码控制，这就用到ServiceCtrl类，该类的接口如下：
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*/

接口比较直观没什么好说的，看下面的示例代码：
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 }

源代码：点击下载

蚂蚁终结者 2007-09-24 13:01 发表评论

从Win32 API封装Thread类[2]

蚂蚁终结者 — Fri, 31 Aug 2007 03:58:00 GMT

在上一篇中介绍了创建Thread的两种方法：从Thread类继承或者实现Runnable接口。有时候这并不是特别方便，我们需要的是更灵活的方法，比如像boost库中的Thread一样可以用普通函数和函数对象
(functor and function object)作为构造函数参数。如果你熟悉STL，你应该熟悉bind1st和bind2nd这两个函数配接器(function adapter)，bind1st和bind2nd可以将一个二元函数(binary function)转换成一元函数(unary function)。为了使Thread类能够用普通函数和函数对象作为参数，我们需要一个bind将一元函数转换成无参函数：
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我们还需要修改Thread类的构造函数，显然我们必须将构造函数声明为成员模板(还有一种方法也可以达到同样的目的，就是把Thread类声明为模板，但是这样的设计好像不太好)，这样才能够让Thread类的构造函数可以接受各种类型的参数，修改后的构造函数应该能够使用如下三种类型的参数：
1.Runnable *
2.no argument function
3.no argument functor
下面是修改后的头文件：
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和前一篇的几乎一样，唯一的不同是去掉了构造函数Thread(Runnable *)，因为现在的构造函数改成了成员模板，实现也放在thread.h中了。现在的构造函数能够接受各种类型的参数，主要归功于模板函数transfer，实现代码在runnable.h中，主要技巧是用类的偏特化模拟函数模板的偏特化，不明白的请看为什么不要特化函数模版。

下面是测试代码：
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 }

当然了，上面的并不是全部，修改后的Thread类不仅能够使用原先的从Thread类继承或者实现Runnable接口的方法，还可以使用任何无参函数或无参函数对象。除了test.cpp里示范的，你甚至可以用bind,bind1st,bind2st,mem_fun,mem_fun_ref的组合来用某个类的成员函数作为参数，具有超强的灵活性。

目前实现的这些都是Thread类最基本的功能，其他功能如设置线程优先级，挂起或恢复线程，异常处理等具体实现都比较简单，这这里就不一一实现了。
源代码下载：点击下载

蚂蚁终结者 2007-08-31 11:58 发表评论

C++&Win32写的空当接龙

蚂蚁终结者 — Thu, 30 Aug 2007 13:37:00 GMT

上学期做课程设计，老师让我做windows自带的空当接龙游戏，写了一个礼拜，完全仿windows的呵呵。
不过也不全一样，有一些细节一直没有时间弄，没办法最近比较懒...

与windows下的相比，我做的这个加入了AI(快捷键F6)，可以开启移牌提示(快捷键F7)，不过撤销一直没有做，可能哪天突然想做了会加上去。另外改进了废牌回收算法，非法移牌的提示直接去掉了，还有一些小的细节作了改进。
感兴趣的可以下载：点击下载
源代码下载：点击下载
顺便发几张截图：

蚂蚁终结者 2007-08-30 21:37 发表评论

为什么不要特化函数模版

蚂蚁终结者 — Thu, 30 Aug 2007 05:55:00 GMT

Overloading vs. Specialization

在C++中有class templates 和function templates，这两种模版有很多区别，最重要的区别就是重载(overloading)：
普通的C++类不能重载，当然类模版也不能重载；相反，普通函数可以重载，函数模版也能重载。这再正常不过，看下面的代码：

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

像上面未特化的模板通常叫做base templates。当然，base templates能够被特化，在特化这一点上
class templates 和function templates有很大的区别：一个class template 能够被partially specialized and/or
fully specialized，一个function template只能被fully specialized，但是由于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

根据函数重载解析规则：

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)

上面说的这些其实都是很简单的情况，大多数人很容易就能明白，下面的才是容易让人弄混的：

1.考虑如下代码：

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)

最后一行的结果像大多数人所期望的一样，问题是：为什么期望是这个结果？
如果你期望的原因是错误的，接下来的一定会让你好奇。也许你会说："我为int*写了一个特化版本，f(p)当然会调用c"，不幸的是，这正是错误的原因!!!

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

如果这个结果让你感到惊奇，那就对了！很多人都会感到惊奇！
理解这个的关键是：Specializations don't overload,only the base templates overload.

重载解析仅仅选择base template(或者nontemplate function，如果有的话)，只有当编译器已经决定了哪个
base template将会被选择，编译器才会继续往下寻找适合的特化版本，如果找到了就使用那个特化版本。

最后，应当避免特化函数模板，也要避免重载函数模板(nontemplate function的重载当然没问题)。如果一定要这样，可以使用如下方法模拟函数模板的偏特化：

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

蚂蚁终结者 2007-08-30 13:55 发表评论

从Win32 API封装Thread类[1]

蚂蚁终结者 — Thu, 30 Aug 2007 02:18:00 GMT

前几天在学Windows多线程程序设计，发现Win32 API用起来确实不怎么方便，特别是对于C++程序员。于是实现了一个简单的封装，技术含量当然不高，不过用起来还是比较方便的。如果你熟悉Java，你会发现这个实现有点像Java的Thread，在Java中有两种方法可以创建一个Thread：

1.从Thread类继承并实现run方法：

1 class MyThread extends Thread {
2     public void run() {
3         ...
4     }
5 };
6
7 //开启线程
8 MyThread thread = new MyThread;
9 thread.start();

2.声明一个类实现Runnable接口并实现run方法：

1 class MyRunnable implements Runnable {
2     public void run() {
3         ...
4     }
5 };
6
7 // 开启线程
8 MyThread thread = new MyThread(new MyRunnable);
9 thread.start();

具体实现
Java的实现方式还算优雅，我们也可以在C++中模拟，由于篇幅所限，在这里我们只关注基本功能的实现：
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类，并为Runnable类添加纯虚函数run，需要特别注意的是Runnable类的虚析构函数，任何想要成为基类的class都应该声明析构函数为virtual。
Thread类直接继承自Runnable，CLASS_UNCOPYABLE(Thread) 这一行用宏声明Thread类不可拷贝，具体细节请看考虑用Macro替换Uncopyable 。start成员函数和Java中的一样，用来开启一个线程，join成员函数用来阻塞当前线程直到开启的线程执行完毕。threadProc作为静态成员函数用来传递给_beginthreadex，至于为什么用_beginthreadex代替CreateThread请问Google。初步的实现都比较简单，直接贴上代码：
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 //第一种方法，从Thread类继承
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 //第二种方法，“实现”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构造函数可以接受普通函数和函数对象作为参数，如果你觉得从Thread类继承或者实现Runnable接口还不够简洁，下一篇会有一个比较好的改进。

蚂蚁终结者 2007-08-30 10:18 发表评论

考虑用Macro替换Uncopyable

蚂蚁终结者 — Mon, 27 Aug 2007 00:11:00 GMT

看过Effective C++的人都知道，为了防止一个class被copying，而且将错误提前到编译期，基本有两种方法：
1. 将这个类的copy构造函数和copy assignment操作符都声明为private而且没有定义。示例代码如下：

1 class SomeClass {
2     ...
3 private:
4     //只有声明
5     SomeClass(const SomeClass&);
6     SomeClass& operator=(const SomeClass&);
7 };

2. 专门设计一个为了阻止copying动作而设计的base class，这个base class相当简单：

1 Uncopyable {
2 protected: //允许derived对象构造和析构
3     Uncopyable() {}
4     ~Uncopyable() {}
5 private: //阻止copying
6     Uncopyable(const Uncopyable&);
7     Uncopyable& operator=(const Uncopyable&);
8 };

为了阻止某个对象如SomeClass被copying，我们唯一需要做的就是继承自Uncopyable：

1 SomeClass : private Uncopyable {
2 ...
3 };

第2种方案貌似很完美，在大多数情况下也工作的很好，甚至boost库也广泛采用了(boost库中的叫noncopyable)。当然了，因为Uncopyable不含任何数据，符合EBO(empty base class optimization，空白基类最优化)资格，但由于它总是扮演base class，因此有可能导致多重继承，而EBO一般只在单继承下才可行，编译器通常不会对有多个base class的derived classes施行EBO。

如果你不想导致多重继承，不管是从性能上还是书写代码上，比如SomeClass继承自某个base class，你可能会写如下代码：

1 class SomeClass : public BaseClass, private Uncopyable {
2 ...
3 };

这让人很不爽，要是你跟我一样懒，你肯定也不会愿意采用第一种方案，因为那意味着你会在每一个不想被copying的class里都加上那三行代码。

如果用Macro就很简单了，即灵活又方便：

1 #define CLASS_UNCOPYABLE(classname) \
2     private: \
3     classname(const classname&); \
4     classname& operator=(const classname&);

现在SomeClass只需写成这样：

1 class SomeClass {
2 CLASS_UNCOPYABLE(SomeClass)
3 ...
4 };

不仅省事而且灵活！！！

蚂蚁终结者 2007-08-27 08:11 发表评论