C++博客-kenlistian-随笔分类-cpp

发送消息给线程

kenlistian — Sun, 22 Mar 2009 05:06:00 GMT

采用PostThreadMessage即可

BOOL PostThreadMessage(
  DWORD idThread, //线程ID,通过创建线程后的id
  UINT Msg, //消息id
  WPARAM wParam,
  LPARAM lParam);

然后在线程通过GetMessage or PeekMessage去获取该消息.

代码片段如下:

unsigned int CALLBACK thread_func(LPVOID lp)

{

while(1)

{

MSG msg;

while (GetMessage(&msg, NULL, 0, 0))

//while (PeekMessage(&msg, NULL, 0, 0,PM_REMOVE))

{

switch(msg.message)

{

case WM_MYMESSAGE:

printf("\n *thread_func1:%d", msg.wParam);

break;

}

其中发送线程片段如下:

UINT dwId

_beginthreadex(NULL, 0, thread_func, NULL, 0, &dwId);

...

附:

GetMessage(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax)

PeekMessage(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax,UINT wRemoveMsg)

参数wRemoveMsg的作用是指定消息获取的方式，如果设为PM_NOREMOVE,那么消息将不会从消息队列中被移出，如果设为PM_REMOVE，那么消息将会从消息队列中被移出；

两个函数主要有以下两个区别:

1.GetMessage将等到有合适的消息时才返回,而PeekMessage只是撇一下消息队列。(GetMessage 处于挂起等待消息来,而PeekMessage则不管有不有消息都返回)

2.GetMessage会将消息从队列中删除,而PeekMessage可以设置最后一个参数wRemoveMsg来决定是否将消息保留在队列中。(如果保留在队列中,最好立即处理)

在Windows的内部，GetMessage和PeekMessage执行着相同的代码。而两者最大的不同之处则体现在没有任何消息返回到应用程序的情况下。在此种情况下，PeekMessage会返回一个空值到应用程序，GetMessage会在此时让应用程序休眠。

(如果在线程中使用,用GetMessage or PeekMessage都无所谓,不需要考虑消息队列的remove,消息队列在各个线程中不过是个拷贝?而已.)

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1573835

kenlistian 2009-03-22 13:06 发表评论

waitformultipleobjects点滴

kenlistian — Tue, 17 Mar 2009 10:50:00 GMT

该函数等待handle信号发来,它的好处在于可以等待多个信号发来.
原型：
DWORD WaitForMultipleObjects(
DWORD nCount,
const HANDLE* lpHandles,
BOOL bWaitAll,
DWORD dwMilliseconds
);

第一个参数表示信号数目.
当设置bWaitAll = True,表示必须其信号必须都达到nCount才可以下一步.而不是lpHandle数组的信号都到.
同时,如果lpHandle的某个信号SetEvent多次,是不会累计到nCount中,也就是说,当多个线程在处理完以后,可以在各自的线程体必须调用不同的event句柄来发信号,它才会被累计达到nCount后解锁进入下一步.

kenlistian 2009-03-17 18:50 发表评论

关于link2001错误

kenlistian — Thu, 13 Nov 2008 17:26:00 GMT

经常在链接是报link2001错误，其中一般是函数体没有定义错误。但是排除以上简单的外，还有一种如下无法解析系统文件中的函数定义。如下：

LINK : warning LNK4098: 默认库“LIBCMT”与其他库的使用冲突；请使用 /NODEFAULTLIB:library
libcpmtd.lib(cerr.obj) : error LNK2001: 无法解析的外部符号 __CrtDbgReportW
libcpmtd.lib(stdthrow.obj) : error LNK2001: 无法解析的外部符号 __CrtDbgReportW
。。。。。。
libcpmtd.lib(_tolower.obj) : error LNK2019: 无法解析的外部符号 __calloc_dbg，该符号在函数 __Getctype 中被引用

像这种情况，可以推测运用了错误的运行库包。

在一程序中使用不同类型的运行时库或使用调试和非调试版本的运行时库，则将收到此链接错误。

例如，编译一个文件以使用一种运行时库，而编译另一个文件以使用另一种运行时库（例如单线程运行时库对多线程运行时库），试图链接它们，则将得到此警告。应将所有源文件编译为使用同一运行时库。

其实就是调正编译器选项参数：/MD、/MT 和 /LD

在vc8中，在“配置属性-->C/C++-->代码生成-->运行时库”中将“多线程（/MT）”统一改为“多线程调试（/MTd）”即可。

kenlistian 2008-11-14 01:26 发表评论

汇总函数指针理解

kenlistian — Wed, 29 Oct 2008 14:23:00 GMT

一个函数指针的理解：
　有一段程序存储在起始地址为 0的一段内存上，如果我们想要调用这段程序，请问该如何去做？
　答案是 (*(void (*)( ) )0)( )。

　首先，最基本的函数声明： void function (paramList);
　最基本的函数调用： function(paramList);

　　鉴于问题中的函数没有参数，函数调用可简化为 function();
　根据问题描述，可以知道 0是这个函数的入口地址，也就是说，0是一个函数的指针。
   使用函数指针的函数声明形式是：void (*pFunction)()，相应的调用形式是： (*pFunction)()，
   则问题中的函数调用可以写作：(*0)( )。

　　大家知道，函数指针变量不能是一个常数，因此上式中的 0必须要被转化为函数指针。

　　我们先来研究一下，对于使用函数指针的函数：
        比如 void (*pFunction)( )，函数指针变量的原型是什么？
    这个问题很简单，pFunction函数指针原型是( void (*)( ) )，即去掉变量名，
    清晰起见，整个加上（）号。

　　所以将 0强制转换为一个返回值为void，参数为空的函数指针如下：( void (*)( ) )。

　　 OK，结合2)和3)的分析，结果出来了，那就是：(*(void (*)( ) )0)( ) 。

　　答案分析：从头到尾理解答案

　　 (void (*)( )) ，是一个返回值为void，参数为空的函数指针原型。
　　 (void (*)( ))0，把0转变成一个返回值为void，参数为空的函数指针，指针指向的地址为0.
　　 *(void (*)( ))0，前面加上*表示整个是一个返回值为void的函数的名字
　　 (*(void (*)( ))0)( )，这当然就是一个函数了。

　　我们可以使用 typedef清晰声明如下：

　　 typedef void (*pFun)();

这样定义之后，pFun就是一个返回类型为void无参数的函数指针变量了。

　　这样函数变为 (*(pFun)0)();

----
在调用动态库时，习惯用typedef重新定义动态库函数中的函数地址（函数指针），
如在动态库（test.dll）中有如下函数：
int DoCase(int, long);

则，在调用动态库是有两种方法：
1. 先声明一个与动态库中类型一致的指针函数变量：

int (*DOCASE)(int ,long);  //用于指向动态库中的DoCase函数地址
HINSTANCE gLibMyDLL = NULL;
gLibMyDLL = LoadLibrary("test.dll");
if(gLibMyDLL != NULL)
{
  DOCASE = (int(*)(int,long))GetProcAddress(gLibMyDLL, "DoCase");
}
int s = DOCASE(1,1000);

2.用typedef定义一个指针函数：
typedef (*DOCASE)(int ,long);

HINSTANCE gLibMyDLL = NULL;
DOCASE _docase;
gLibMyDLL = LoadLibrary("test.dll");
if(gLibMyDLL != NULL)
{
  _docase = (DOCASE)GetProcAddress(gLibMyDll, "DoCase");
}

int s=_docase(1,1000);

----------------
在C++类中使用函数指针。

//typedef 返回类型(类名::*新类型)(参数表)
class CA
{
public:
  char lcFun(int a){ return; }
};

CA ca;
typedef char (CA::*PTRFUN)(int);
PTRFUN pFun;
void main()
{
  pFun = CA::lcFun;
  ca.(*pFun)(2);
}

指针的定义与使用都加上了“类限制”或“对象”，用来指明指针指向的函数是哪个类的,
这里的类对象也可以是使用new得到的。
如：
CA *pca = new CA;
pca->(*pFun)(2);
delete pca;
而且这个类对象指针可以是类内部成员变量，你甚至可以使用this指针。
如：类CA有成员变量PTRFUN m_pfun;
void CA::lcFun2()
{
(this->*m_pFun)(2);
}
一句话，使用类成员函数指针必须有“->*”或“.*”的调用。

--------------------

void test(void* );
void tt()
{
   printf("kao,没玩过这种\n");
}

int main(int argc, char* argv[])
{
    typedef void(*Fun)();
    Fun mytest;
    mytest = tt;
    test((void*)mytest);
    return 0;
}

void test(void * p)
{
    (*(void(*)())p)();
}

kenlistian 2008-10-29 22:23 发表评论

offsetof 的理解

kenlistian — Mon, 27 Oct 2008 09:16:00 GMT

关于偏移量的宏定义

#define offsetof(s,m)   (size_t)&(((s *)0)->m)

s是一个结构名，它有一个名为m的成员（s和m 是宏offsetof的形参，
它实际是返回结构s的成员m的偏移地址

(s *)0 是骗编译器说有一个指向类（或结构）s的指针，其地址值0

&((s *)0)->m   是要取得类s中成员变量m的地址
    因基址为0，这时m的地址当然就是m在s中的偏移

最后转换size_t 型，即unsigned int。

有例子如：
struct   AAA
{
    int   i;
    int   j;
};

struct   AAA   *pAAA;
pAAA = new   AAA;
这时，pAAA实际上是一个Pointer, 指向某一确定的内存地址，
     如0x1234;
而pAAA->i 整体是一个int型变量，其地址是&(pAAA->i),
'&'为取址运算符；
那么&(pAAA->i)一定等于0x1234,因 i 是结构体AAA的第一个元素。
而&(pAAA->j)一定是0x1234 + 0x4 = 0x1238; 因为sizeof(int) = 4;

这个做法的巧妙之处就是：它把“0”作为上例中的pAAA,那么&(pAAA->j)就是j的
offset啦，

解析结果是：
(s*)0,将 0 强制转换为Pointer to "s"
可以记 pS = (s*)0，pS是指向s的指针，它的值是0;
那么pS->m就是m这个元素了，而&(pS->m)就是m的地址，
就是offset啦

kenlistian 2008-10-27 17:16 发表评论

备注ado加头文件

kenlistian — Thu, 17 Jul 2008 02:21:00 GMT

ado在dll中使用如下的头文件

#pragma warning(disable:4146)
#import "C:\Program Files\Common Files\System\ADO\msado15.dll" named_guids rename("EOF","adoEOF"), rename("BOF","adoBOF")
#pragma warning(default:4146)

using namespace ADODB;

"Provider=SQLOLEDB,Data Source=serverName;Initial Catalog=databaseName;User ID=userName;Password=userPassword;"

#import "c:\program files\common files\system\ado\msado15.dll" no_namespaces rename("EOF","adoEOF")

http://www.pconline.com.cn/pcedu/empolder/gj/vc/0507/653859.html

kenlistian 2008-07-17 10:21 发表评论

bind1nd 和bind2nd的意思

kenlistian — Mon, 14 Jul 2008 08:56:00 GMT

采用bind1st和bind2nd的意思，就是把参数绑定在第一位还是第二位。
继承于binary_function 类.
描述如下
Class binder1st binds the value to the first argument of the binary function, and binder2nd does the same thing
for the second argument of the function.

如下：例子

struct compare_str :binary_function
{
public:
    bool operator()(ST_DataResult* pDataRet, char* szTypeCode) const
    {
        return strcmp(pDataRet->sType , szTypeCode) == 0 ? true : false;

    }
};

。。。

char szTypeCode[4] = {'\0'};
strcpy(szTypeCode, sTypeCode);
pIt = find_if(m_d_ret_data.begin(), m_d_ret_data.end(),
        bind2nd(compare_str(), szTypeCode));

其中把szTypeCode变量传入到compare_str所定义的第二个参数位置传入。
如果写成bind1nd, 则是把szTypeCode作为第一个参数传入，那么会报错。
因为类型不对。

kenlistian 2008-07-14 16:56 发表评论

wxWidgets的配置

kenlistian — Tue, 03 Jun 2008 10:13:00 GMT

目前是wxWidgets-2.8.7，
下载http://sourceforge.net/project/showfiles.php?group_id=9863

其中在windows下，则选择其中msw的压缩下载。
按照install文档要求，编译wxWdigets中的builder目录中的wx。bsp。
由于该wxwdgets支持多种编译器，选择相关的工程文件加载。

传统采用vc6.

生成的编译文件在lib目录中。如果采用vc则目录为vc_lib.

生成的lib文件有(release or debug)：

 wxbase28.lib              wxbase28d.lib
wxbase28_net.lib          wxbase28d_net.lib
wxbase28_xml.lib          wxbase28d_xml.lib
wxmsw28_core.lib          wxmsw28d_core.lib
wxmsw28_html.lib          wxmsw28d_html.lib
wxmsw28_adv.lib           wxmsw28d_adv.lib

在vc中设置lib，可以把该目录加入，也可以直接把生成的文件丢在vc的lib目录。

关于unicode模式编辑如上。

在include设置中，需要加入wxWidgets目录中的include目录。

运行demo程序测试.

注意：在include也需要把setup.h头文件加入。该头也根据生成的lib目录中调用。
      不过最好加在预处理的include directory目录编辑框中。

kenlistian 2008-06-03 18:13 发表评论

EnBase64 and DeBase64 code

kenlistian — Wed, 23 Apr 2008 04:06:00 GMT

摘要: Base64 编码和解码，说到Base64编码和解码，不过就是把3个字节进行处理后放置到4个字节空间。其原理就是：待编码数据，以3个字节为单位，依次取6位数据并在前面补上两个0形成新的8位编码，由于3*8=4*6，这样3个字节的输入会变成4个字节的输出，长度上增加了1/3。以上处理存在着字符不是可见字符，... 阅读全文

kenlistian 2008-04-23 12:06 发表评论

一个简单的队列

kenlistian — Tue, 15 Jan 2008 07:13:00 GMT

  1 #include <list>
  2
  3 using namespace std;
  4
  5 class CYException
  6 {
  7 public:
  8     CString sMsg;
  9     int nError;
10     CYException(int nErr,char* sErrMsg){
11         nError = nErr;
12         sMsg  = sErrMsg;
13     }
14     virtual ~CYException(){}
15
16 };
17
18 template   <class  T>
19 class   CYQueueSyn
20 {
21   public:
22       std::list<T>   queue;
23       int   m_outtime;
24       HANDLE   m_readSem;
25       HANDLE   m_writeSem;
26       HANDLE   m_synObject;
27   public:
28       CYQueueSyn(int length,int  outtime = INFINITE);
29       virtual   ~CYQueueSyn(void);
30   public:
31       void   inq(T type);
32       T   outq();
33
34       void   free();
35 };
36 ////////////////////////////////////////////////////////
37 template<class   T>
38 void   CYQueueSyn<T>::free()
39 {
40     int   size = (int)queue.size();
41     for(int i = 0; i<size; i++)
42         delete queue.back();
43     queue.clear();
44 }
45 template<class T>
46 CYQueueSyn<T>::CYQueueSyn(int   length,int   outtime)
47 {
48     m_readSem = CreateSemaphore(NULL,0,length,NULL);
49     m_writeSem = CreateSemaphore(NULL,length,length,NULL);
50     m_synObject = ::CreateMutex(NULL,false,NULL);
51
52     m_outtime = outtime;
53 }
54 template<class T>
55 CYQueueSyn<T>::~CYQueueSyn()
56 {
57     CloseHandle(m_readSem);
58     CloseHandle(m_writeSem);
59     CloseHandle(m_synObject);
60 }
61
62 template<class T>
63 void   CYQueueSyn<T>::inq(T type)   throw(CYException)
64 {
65     int  rVal = WaitForSingleObject(m_writeSem,m_outtime);
66     if(rVal == WAIT_OBJECT_0)
67     {
68         if(WaitForSingleObject(m_synObject,INFINITE) == WAIT_OBJECT_0)
69         {
70             queue.push_back(type);
71             ReleaseMutex(m_synObject);
72         }
73     }
74     else if(rVal == WAIT_TIMEOUT)
75     {
76         throw CYException(1,"TIMEOUT");
77     }
78     else if(rVal == WAIT_ABANDONED)
79     {
80         throw CYException(-1, "ERROR");
81     }
82     ReleaseSemaphore(m_readSem,1,NULL);
83 }
84 template<class T>
85 T  CYQueueSyn<T>::outq()   throw(CYException)
86 {
87     T  value;
88     int rVal = WaitForSingleObject(m_readSem,m_outtime);
89     if(rVal == WAIT_OBJECT_0)
90     {
91         if(WaitForSingleObject(m_synObject,INFINITE) == WAIT_OBJECT_0)
92         {
93             value = queue.front();
94             queue.pop_front();
95             ReleaseMutex(m_synObject);
96         }
97     }
98     else if(rVal == WAIT_TIMEOUT)
99     {
100         throw CYException(1,"TIMEOUT");
101     }
102     else if(rVal == WAIT_ABANDONED)
103     {
104         throw CYException(-1,"ERROR");
105     }
106
107     ReleaseSemaphore(m_writeSem,1,NULL);
108     return   value;
109 }
110
111 #endif

如上，测试代码下载：http://www.pudn.com/downloads97/sourcecode/windows/other/109201257cqueue.rar

kenlistian 2008-01-15 15:13 发表评论

windows 信号量的运用笔记

kenlistian — Tue, 04 Dec 2007 06:18:00 GMT

在windows下：信号量（Semaphore）内核对象对线程的同步方式，它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。 CreateSemaphore() OpenSemaphore() ReleaseSemaphore(), WaitForSingleObject()/WaitForMultipleObjects() CreateSemaphore（）创建信号量时即要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目，不能在允许其他线程的进入，此时的信号量信号将无法发出。线程在处理完共享资源后，应在离开的同时通过ReleaseSemaphore()函数将当前可用资源计数加1。在任何时候当前可用资源计数决不可能大于最大资源计数。说明如下： HANDLE CreateSemaphore( 　LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, // 安全属性指针　LONG lInitialCount, // 初始计数　LONG lMaximumCount, // 最大计数，定义了允许的最大资源计数　LPCTSTR lpName // 对象名指针，创建的信号量定义一个名字，其创建的是一个内核对象，因此在其他进程中可以通过该名字而得到此信号量 ); OpenSemaphore()函数即可用来根据信号量名打开在其他进程中创建的信号量，函数原型如下： HANDLE OpenSemaphore( 　DWORD dwDesiredAccess, // 访问标志　BOOL bInheritHandle, // 继承标志　LPCTSTR lpName // 信号量名 ); 　在线程离开对共享资源的处理时，通过ReleaseSemaphore（）来增加当前可用资源计数。否则将会出现当前正在处理共享资源的实际线程数并没有达到要限制的数值，而其他线程却因为当前可用资源计数为0而仍无法进入的情况。 BOOL ReleaseSemaphore( 　HANDLE hSemaphore, // 信号量句柄　LONG lReleaseCount, // 计数递增数量　LPLONG lpPreviousCount // 先前计数,可以设置为NULL， ); 　　该函数将lReleaseCount中的值添加给信号量的当前资源计数，一般将lReleaseCount设置为1， WaitForSingleObject和WaitForMultipleObjects主要用在试图进入共享资源的线程函数入口处，主要用来判断信号量的当前可用资源计数是否允许本线程的进入。只有在当前可用资源计数值大于0时，被监视的信号量内核对象才会得到通知。

kenlistian 2007-12-04 14:18 发表评论