久久99国产精品99久久,狠狠色丁香婷婷久久综合,久久综合久久自在自线精品自

Wed, 19 May 2010 14:14:00 GMT

好久没更新日志了�Q�发一则小招聘�q�告�Q?br />
腾讯�q�州招聘手机客户端开发�h�?br /> 基本要求�Q?br /> 1).1�?�q�工作经验；
2).有Symbian/Andriod/iPhone手机客户端开发经�?有Symbian C++开发经验者优�?�Q?/b>

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

蚂蚁�l�结�?/a> 2010-05-19 22:14 发表评论

Mon, 24 Sep 2007 05:01:00 GMT

前段旉��学习(f��n)Windows�E�序设计�Q�刚好学到Win32 Service�Q�于是写了两个简单的�c�：(x��)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中：(x��)
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函数��O(ji��n)K了：(x��)
�?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�则在命令行中可以如下��用：(x��)
(1). beep -i    安装service(安装以后�pȝ��q�行时会(x��)自动启动)
(2). beep -u   卸蝲service(如果service正在�q�行�Q�则先停止service再卸�?
BaseServiced 的ParseStandardArgs正是用来解析上述两个命��o(h��)�?br>
2. ServiceCtrl
虽然Windows自带的Service Control Manager可以控制服务�E�序�Q�但是很多时候我们都需要用代码控制�Q�这��q��到ServiceCtrl�c�，该类的接口如下：(x��)
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�看下面的示例代码：(x��)
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 }

源代码：(x��)点击下蝲

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

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

Fri, 31 Aug 2007 03:58:00 GMT
在上一��中介绍了创建Thread的两�U�方法：(x��)从Thread�cȝ��承或者实现Runnable接口。有时候这�q�不是特别方便，我们需要的是更灉|��的方法，比如像boost库中的Thread一样可以用普通函数和函数对象
(functor and function object)作�ؓ(f��)构造函数参数。如果你熟�?zh��n)�STL�Q�你应该熟�?zh��n)�bind1st和bind2nd�q�两个函数配接器(function adapter)�Q�bind1st和bind2nd可以��一个二元函�?binary function)转换成一元函�?unary function)。�ؓ(f��)了��Thread�c�能够用普通函数和函数对象作�ؓ(f��)参数�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ȝ��构造函敎ͼ�昄��我们必须��构造函数声明�ؓ(f��)成员模板(�q�有一�U�方法也可以辑ֈ�同样的目的，��是把Thread�c�d��明�ؓ(f��)模板�Q�但是这��L(f��ng)��设计好像不太�?�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 />
下面是测试代码：(x��)
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�这里就不一一实现了�?
源代码下载：(x��)点击下蝲

蚂蚁�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(di��n)�?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�可能哪天突然想做了�?x��)加上去。另外改�q�了废牌回收��法�Q�非法移牌的提示直接��L��了，�q�有一些小的细节作了改�q��?br>感兴��的可以下蝲�Q?a title=点击下蝲 href="http://www.shnenglu.com/Files/ant/Freecell.rar">点击下蝲
源代码下载：(x��)点击下蝲
��Z��发几张截图：(x��)

蚂蚁�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 相当的功能。下面的代码说明了这些区别：(x��)

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

�Ҏ(gu��)��函数重蝲解析规则�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�大多数人很�Ҏ(gu��)��p��明白�Q�下面的才是�Ҏ(gu��)��让�h弄�؜的：(x��)

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��问题是：(x��)��Z��么期望是�q�个�l�果�Q?br />如果你期望的原因是错误的�Q�接下来的一定会(x��)让你好奇。也�怽��?x��)说�Q?我�ؓ(f��)int*写了一个特化版本，f(p)当然�?x��)调�?span style="COLOR: #3366ff">c"�Q�不�q�的是，�q�正是错误的原因!!!

2.再考虑下面的代码：(x��)

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�那��对了！很多人都�?x��)感到惊奇�?br />理解�q�个的关键是�Q?em style="COLOR: #993300">Specializations don't overload,only the base templates overload.

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

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来还是比较方便的。如果你熟�?zh��n)�Java�Q�你�?x��)发现这个实现有点像Java的Thread�Q�在Java中有两种�Ҏ(gu��)��可以创徏一个Thread�Q?br />
1.从Thread�cȝ��承�ƈ实现run�Ҏ(gu��)��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�Ҏ(gu��)��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��基本功能的实玎ͼ�(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��ؓ(f��)Runnable�c�L��加纯虚函数run�Q�需要特别注意的是Runnable�cȝ��虚析构函敎ͼ��M��惌��成�ؓ(f��)基类的class都应该声明析构函��Cؓ(f��)virtual�?br />Thread�cȝ��接��承自Runnable�Q�CLASS_UNCOPYABLE(Thread) �q�一行用宏声明Thread�c�M��可拷贝，具体�l�节��L(f��ng)�� 考虑用Macro替换Uncopyable 。start成员函数和Java中的一��P��用来开启一个线�E�，join成员函数用来��d��当前�U�程直到开启的�U�程执行完毕。threadProc作�ؓ(f��)静态成员函数用来传递给_beginthreadex�Q�至于�ؓ(f��)什么用_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 }

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

可能的运行结果：(x��)
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

如果你熟�(zh��n)�boost库，你会(x��)知道boost库的Thread构造函数可以接受普通函数和函数对象作�ؓ(f��)参数�Q�如果你觉得从Thread�cȝ��承或者实现Runnable接口�q�不够简�z�，下一��会(x��)有一个比较好的改�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�方法：(x��)
1. ��这个类的copy构造函数和copy assignment操作�W�都声明为private而且没有定义。示例代码如下：(x��)
1 class SomeClass {
2     ...
3 private:
4     //只有声明
5     SomeClass(const SomeClass&);
6     SomeClass& operator=(const SomeClass&);
7 };

2. 专门设计一个�ؓ(f��)了阻止copying动作而设计的base class�Q�这个base class相当��单：(x��)
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�编译器通常不会(x��)�Ҏ(gu��)��多个base class的derived classes施行EBO�?br />
如果你不惛_��致多重��承，不管是从性能上还是书写代码上�Q�比如SomeClass�l�承自某个base class�Q�你可能�?x��)写如下代码�Q?br />
1 class SomeClass : public BaseClass, private Uncopyable {
2     ...
3 };

�q�让人很不爽�Q�要是你跟我一��h��Q�你肯定也不�?x��)愿意采用第一�U�方案，因�ؓ(f��)那意味着你会(x��)在每一个不惌��copying的class里都加上那三行代码�?br />
如果用Macro��很��单了�Q�即灉|��又方便：(x��)
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国产精品99久久,狠狠色丁香婷婷久久综合,久久综合久久自在自线精品自

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

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

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

考虑用Macro替换Uncopyable

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

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