vc settimer后一定要用killtimer吗

不了解c# vc中settimer用法：settimer（ HWND hWnd,UINT_PTR nIDEvent,UINT uElapse,TIMERPROC lpTimerFunc）；其中hWnd默认为当前窗口句柄，_PTR为计时器编号，ublapse 为时间间隔，lpTimerFunc为一个时间间隔所执行的函数如为null执行Ontimer（）；例如：settimer（1,1000,null）;结束可以用killtimer（1）；结束计时器

先请看SetTimer这个API函数的原型 UINT_PTR SetTimer( HWND hWnd, // 窗口句柄 UINT_PTR nIDEvent, // 定时器ID，多个定时器时，可以通过该ID判断是哪个定时器 UINT uElapse, // 时间间隔,单位为毫秒 TIMERPROC lpTimerFunc // 回调函数);例如 SetTimer(m_hWnd,1,1000,NULL); //一个1秒触发一次的定时器在MFC程序中SetTimer被封装在CWnd类中，调用就不用指定窗口句柄了于是SetTimer函数的原型变为： UINT SetTimer(UINT nIDEvent,UINT nElapse,void(CALLBACK EXPORT *lpfnTimer)(HWND,UINT ,YINT ,DWORD)) 当使用SetTimer函数的时候，就会生成一个计时器。函数中nIDEvent指的是计时器的标识，也就是名字。nElapse指的是时间间隔，也就是每隔多长时间触发一次事件。第三个参数是一个回调函数，在这个函数里，放入你想要做的事情的代码，你可以将它设定为NULL，也就是使用系统默认的回调函数，系统默认认的是onTime函数。这个函数怎么生成的呢？你需要在需要计时器的类的生成onTime函数：在ClassWizard里，选择需要计时器的类，添加WM_TIME消息映射，就自动生成onTime函数了。然后在函数里添加代码，让代码实现功能。每隔一段时间就会自动执行一次。 例： SetTimer(1,1000,NULL); 1：计时器的名称； 1000：时间间隔，单位是毫秒； NULL：使用onTime函数。 当不需要计时器的时候调用KillTimer(nIDEvent); 例如：KillTimer(1); 当要使用回调函数时，此方法首先写一个如下格式的回调函数void CALLBACK TimerProc(HWND hWnd,UINT nMsg,UINT nTimerid,DWORD dwTime);然后再用SetTimer(1,100,TimerProc)函数来建一个定时器，第三个参数就是回调函数地址。或许你会问，如果我要加入两个或者两个以上的 timer怎么办？ 继续用SetTimer函数吧，上次的timer的ID是1，这次可以是2，3，4。。。。 SetTimer(2,1000,NULL); SetTimer(3,500,NULL); 嗯，WINDOWS会协调他们的。当然onTimer函数体也要发生变化，要在函数体内添加每一个timer的处理代码： onTimer(nIDEvent) { switch(nIDEvent) { case 1:........; break; case 2:.......; break; case 3:......; break; } }

SetTimer第一个参数是记时器id第2个参数是间隔时间，单位为毫秒第3个参数是一个函数指针，并且要求是一个回调函数。当设定好定时器之后，每隔设定的时间间隔，它就会发送一条定时器消息。如果在这里设置了回调函数，这时操作系统就会调用这个回调函数来处理定时器消息，如果设置为NULL,定时器消息，即WM_TIMER消息就会放到应用程序的消息队列中，然后由程序中响应此消息的窗口对象来处理(即可以添加OnTimer消息函数进行响应)如果第3个参数的意思你看不懂，建议你看看win32 sdk编程SetTimer函数一般放在OnCreate函数中如你在OnCreate函数中添加SetTimer(1,200,NULL);并且添加OnTimer消息函数(如在view类里添加，那么右击它选添加window消息处理函数，然后找到WM_TIMER,添加就可以了)那么过200毫秒 就会调用一次OnTimer函数还不懂可以加我QQ568722270

MFC中的定时器大致分为4个步骤：1.在需要添加定时器的类名上右键选择Add Windows Message Handler，然后添加相应消息WM_TIMER.2.在程序中需要启动计时器的地方UINT SetTimer( UINT nIDEvent, UINT nElapse, void (CALLBACK EXPORT* lpfnTimer)( HWND, UINT, UINT, DWORD) ); 第一个参数为定时器id,第二个参数为间隔时间，以毫秒为单位，第三个参数为处理过程入口地址，一般为NULL;例如SetTimer(1,500,NULL);3.在CXXXDlg::OnTimer(UINT nIDEvent)；函数中添加处理代码4.在需要销毁定时器的地方BOOL KillTimer( int nIDEvent ); //参数为定义器的id,需与SetTimer中一致例如KillTimer(1);

应为SetTimer的后，过100ms才收到WM_TIMER的消息，开始显示倒计时；而仿真函数在SetTimer后就立即执行了，所以是先执行了仿真函数，100ms后执行倒计时。你把仿真函数放到WM_TIMER的消息函数中就可以了。

1、可以是0，0的时候返回的是一个新的timer，并拥有一个随机的id，这个id你可以查看settimer的返回值或timerproc的iTimerID参数。2、hwnd是timer所关联的窗口句柄，settimer时的第一个参数；uint是timer消息WM_TIMER == 0x113；itimerid是timer的id，就是settimer第一个参数!=NULL，第二个参数!=0时指定的数字；dwTime == GetTickCount()返回的值外部调用的话，你传过去什么值就是什么值系统调用相当于TimerProc(hwnd, WM_TIMER, id, GetTickCount())

你可以使用两个定时器，比如定时器0和1，按按钮1时，启动定时器0：SetTimer(0,1000,0);按按钮2时，启动定时器1：SetTimer(1,1000,0);定时器消息函数应该这样写：CXXX::OnTimer(UINT nIDEvent)//说明：CXXX是你自己添加定时器的类{ // TODO: Add your message handler code here and/or call default switch (nIDEvent) { case 0://如果是定时器0时间到 a();//调用一次a() break; case 1://如果是定时器1时间到 b();//调用一次b() break; default:break; } CXXX::OnTimer(nIDEvent);}

第一个参数为对应时器的代号。在一个程序中，可能有多个SetTimer，在Ontime响应时，可以根据第一个参数来确定是哪一个记时器所引起的事件。 第三个参数为一个回调函数的指针，用NULL的话，系统会把SetTimer产生的消息加入消息队列中。

是在AfxMessageBox弹出的消息框的消息循环里，又处理了WM_TIMER，然后又弹出对话框的结果。你可以把MFC调成静态链接，然后调试，然后让它弹出8个MessageBox，不要点掉，在VC里暂停进程，之后VC可能会停在某个类似汇编代码的地方，此时找调用堆栈窗口（call stack），检查调用栈，你可以看到好几个OnTimer好几个AfxMessageBox在调用栈里。就是这么回事：AfxMessageBox还没返回，结果又开始处理WM_TIMER了（直接在运行AfxMessageBox的线程（消息循环）上开始处理消息AfxMessageBox之所以可以在你点掉窗口之前不返回，不返回的同时还能让你后面那些窗口不会没有响应，就是这个原理：它内部运行了一个消息循环。

问题1：两种方法都可以，如果给SetTimer的最后一个参数传入NULL，需要添加WM_TIMER消息映射，让VC自动生成OnTimer函数；如果传入一个回调函数地址，系统就会调用你写的回调函数。除了写法略有不同，二者几乎没啥区别的。如果你要设置多个计时器，如果使用OnTimer函数，需要在其内部区分计时器ID值；如果使用回调函数，可以为每个定时器传入不同的回调函数，这就它们的区别。问题2：如果使用OnTimer函数，必须在窗口类内部添加WM_TIMER消息映射，并在窗口类内部实现OnTimer进行消息响应。如果使用回调函数，这个函数可以是全局的。回调函数的声明可以是这样：void CALLBACK MyTimerProc(HWND hWnd,UINT nMsg,UINT nIDEvent,DWORD dwTime)参数1是设置定时器的窗口句柄，参数2是消息类型，也就是WM_TIMER，参数3是定时器ID，参数4是时间延迟。你的程序没有创建窗口，不能使用定时器，定时器是依赖于窗口消息的，你必须指定一个处理WM_TIMER消息的窗口。

SetTimer和Sleep是两回事。SetTimer是一个定时器，过一个时间间隔干什么。而在这个时间间隔内，程序还在运行，也可以响应其他的消息。而Sleep，是程序挂起，不响应任何消息，Sleep完之后，才又执行。打个比方，SetTimer就像一心两用。Sleep就像一心一意。

就是定时器 创建定时器：SetTimer(1,1000,NULL);1表示定时器的ID，1000表示没1000ms也就是1s调用一次处理函数，最后一个参数是处理的函数，如果填NULL表示，添加响应函数 对话框右击建立响应事件 WM_Timer在这里面写你要执行的操作就可以了，如果你有多个定时器要在这里写if(nIDEvent == 1)类似的东西去区分不同的定时器 其实比较常用switch(nIDEvent)关闭定时器：KillTimer（1）

settimer 就是定时，意识是你先运行，过了一段时间系统会叫你，也就是相当于你的程序设了个闹钟，你的程序还可以继续运行，sleep是你先睡着，过了一段时间，系统再叫你，就是，你睡觉之前设的闹钟，这段时间你的程序是不运行的。。。

您好，这样的：因为,在调用构造函数时对话框还没有初始化,此时的SetTimer对对话框无效,只有在对话框进行初始化时才能设定其定时器,或者在对话框初始化后SetTimer()也行。不要在构造函数中SetTimer，你如果一定要自动执行的化可以在OnInitDialog或OnShowWindow下面做。还有就是100毫秒这个参数会使OnTimer下的程序在1秒种执行10次，你在里面放一个MessageBox是不是太。另外，如果你要试一下它到底有没有执行的话，可以把SetTimer的参数设大一点，比如2000然后用AfxMessageBox不可你要做好快速反应结束程序的准备，要不然会有。

SetTimer调用后必须等待间隔时间才发送第一条WM_TIMER消息的，如果一定要立刻执行，不妨调用SendMessage直接发送WM_TIMER消息。

当调用SetTimer(1,1000,NULL)就触发WM_TIMER消息,1000为每一秒调用WM_TIMER的消息处理函数，你应该在窗口类中增加一个WM_TIMER消息，然后在OnTimer()函数中写入 m_1++;UpdateData(false);你写的while循环没有意义，因为while循环是以CPU的运行速度来执行的.

第一步：在初始化函数（MFC中是OnInitDialog()）中添加如下代码：SetTimer(1,1,NULL); 其中第一个参数相当于定时器的编号，如果只设置一个定时器写1就行；第二个参数是定时间隔，以毫秒为单位，写1就是1ms，写1000就是1s，可以自己该；第三个参数先不用管，写NULLl就可以。第二步：添加WM_TIMER消息，会自动生成一个OnTimer()函数，把要不断调用的代码放在OnTimer函数中就行了。

基于对话框的MFC，可以直接用SetTimer(ID,time,Proc);Proc()是一个回调函数，每经过time时间（以mS计）调一次Proc()函数，这个函数是你要完成的功能体。另外KillTimer(ID)可以关掉 定时器，这个ID就是SetTimer(ID,time,Proc);里面的ID。这两个前两个函数可以用MFC 的类向导里面的查看->建立类向导->MessageMaps;然后在Class name里选你要实现功能的类，比如叫CMyDlg,然后再Object IDs里选第一个，右边的Messages里可以找到一个叫WM_TIMER的项，选中它，再点右边的Edit Code按钮可以编辑你的定时函数了。这个向导会自动添加上面所说的Proc()函数。这些做完之后，你可以在你需要定时的地方用SetTimer(ID,time,Proc)来启动一个定时器。我有样例程序，需要的话QQmail:woo0301@qq.com

可以的，只要声明API函数即可：Private Declare Function SetTimer Lib "user32" Alias "SetTimer" (ByVal hWnd As Long, ByVal nIDEvent As Long, ByVal uElapse As Long, ByVal lpTimerFunc As Long) As Long

Timer定时器是不准的，因为windows不是实时操作系统，所以都会相差几个微秒。如果要实时显示，只能通过单片机或者其他实时操作系统才行。

#include<stdio.h>#include<windows.h>void setTimer(int time){ while(1){ Sleep(time); printf("你好 "); }}void main(){ setTimer(1500);//参数的单位是毫秒}

不知道你的SetTimer是MFC的还是API的，所以都给你列出来MFC中的SetTimerCWnd::SetTimerUINT SetTimer( UINT nIDEvent, UINT nElapse, void (CALLBACK EXPORT* lpfnTimer)(HWND, UINT, UINT, DWORD) );Return ValueThe timer identifier of the new timer if the function is successful. An application passes this value to the KillTimer member function to kill the timer. Nonzero if successful; otherwise 0.ParametersnIDEventSpecifies a nonzero timer identifier.nElapseSpecifies the time-out value, in milliseconds.lpfnTimerSpecifies the address of the application-supplied TimerProc callback function that processes the WM_TIMER messages. If this parameter is NULL, the WM_TIMER messages are placed in the application"s message queue and handled by the CWnd object.RemarksInstalls a system timer. A time-out value is specified, and every time a time-out occurs, the system posts aWM_TIMER message to the installing application"s message queue or passes the message to an application-defined TimerProc callback function. The lpfnTimer callback function need not be named TimerProc, but it must be defined as follows:void CALLBACK EXPORT TimerProc( HWND hWnd, // handle of CWnd that called SetTimer UINT nMsg, // WM_TIMER UINT nIDEvent // timer identification DWORD dwTime // system time);Timers are a limited global resource; therefore it is important that an application check the value returned by the SetTimer member function to verify that a timer is actually available.Example// This example shows how to use CWnd::SetTimer, CWnd::KillTimer, and how to handle WM_TIMER messages. A timer is set up to send a WM_TIMER message to the main frame window every 2 seconds in OnStartTimer(). OnStopTimer will stop the timer by calling CWnd::KillTimer. OnTimer was set up through class wizard to handle WM_TIMER messages for the main frame window. In this example the PC speaker will beep every 2 seconds.void CMainFrame::OnStartTimer() { m_nTimer = SetTimer(1, 2000, 0);}void CMainFrame::OnStopTimer() { KillTimer(m_nTimer); }void CMainFrame::OnTimer(UINT nIDEvent) { MessageBeep(0xFFFFFFFF); // Beep // Call base class handler. CMDIFrameWnd::OnTimer(nIDEvent);}Windows API中的SetTimerSetTimerThe SetTimer function creates a timer with the specified time-out value. UINT_PTR SetTimer( HWND hWnd, // handle to window UINT_PTR nIDEvent, // timer identifier UINT uElapse, // time-out value TIMERPROC lpTimerFunc // timer procedure);ParametershWnd [in] Handle to the window to be associated with the timer. This window must be owned by the calling thread. If this parameter is NULL, no window is associated with the timer and the nIDEvent parameter is ignored. nIDEvent [in] Specifies a nonzero timer identifier. If the hWnd parameter is NULL, this parameter is ignored. If the hWnd parameter is not NULL and the window specified by hWnd already has a timer with the value nIDEvent, then the existing timer is replaced by the new timer. When SetTimer replaces a timer, the timer is reset. Therefore, a message will be sent after the current time-out value elapses, but the previously set time-out value is ignored. uElapse [in] Specifies the time-out value, in milliseconds. lpTimerFunc [in] Pointer to the function to be notified when the time-out value elapses. For more information about the function, see TimerProc. If lpTimerFunc is NULL, the system posts a WM_TIMER message to the application queue. The hwnd member of the message"s MSG structure contains the value of the hWnd parameter. Return ValuesIf the function succeeds and the hWnd parameter is NULL, the return value is an integer identifying the new timer. An application can pass this value to the KillTimer function to destroy the timer. If the function succeeds and the hWnd parameter is not NULL, then the return value is a nonzero integer. An application can pass the value of the nIDTimer parameter to the KillTimer function to destroy the timer.If the function fails to create a timer, the return value is zero. To get extended error information, call GetLastError.RemarksAn application can process WM_TIMER messages by including a WM_TIMER case statement in the window procedure or by specifying a TimerProc callback function when creating the timer. When you specify a TimerProc callback function, the default window procedure calls the callback function when it processes WM_TIMER. Therefore, you need to dispatch messages in the calling thread, even when you use TimerProc instead of processing WM_TIMER. The wParam parameter of the WM_TIMER message contains the value of the nIDEvent parameter. The timer identifier, nIDEvent, is specific to the associated window. Another window can have its own timer which has the same identifier as a timer owned by another window. The timers are distinct.

你好，关于你的问题，我也不太清楚原因，所以我也尝试着去写了一个程序验证一下，结果并没有出现你所说的情况。代码几乎跟你一样。而对于gww1bd 的回答，我则不同意，MSDN里有讲到如果第一个参数是空的，则第二个参数会被忽略。而我又看到这么一段话：When you specify a TimerProc callback function, the default window procedure calls the callback function when it processes WM_TIMER. Therefore, you need to dispatch messages in the calling thread, even when you use TimerProc instead of processing WM_TIMER. 你可以尝试着去调用LRESULT DispatchMessage( CONST MSG *lpmsg // message information);If the lpmsg parameter points to a WM_TIMER message and the lParam parameter of the WM_TIMER message is not NULL, lParam points to a function that is called instead of the window procedure.

眼都花了。楼主拿支笔自己算一下就知道问题出哪里了。我只想说:楼主的程序模块不好，强烈要求换一下，这样自己调试也可以轻松许多。你在OnTimer里，先计算，然后Invalidate了，这样做很不错，可进入Draw里，又让Draw负责椭圆的计算工作，是不是应该这样做：1）定义个CRect m_rectEllipse;2）在OnTimer中计算m_rectEllipse，在按键按下时也可以计算这个m_rectEllipse。3）在Draw里只负责画椭圆，其他都不做。4）程序还有可以改进的地方，如闪屏会出现吗？定时器分辨率较高时应该会吧！呵呵，说下去一大堆了。P.S.把程序模块调整一下，然后立刻就能发现问题所在了，很好找。

SetTimer()？UINT SetTimer( UINT nIDEvent, //idUINT nElapse, //时间间隔void (CALLBACK EXPORT* lpfnTimer)( HWND, UINT, UINT, DWORD) ); //回调函数,一般为NULL调用这个函数，然后添加OnTimer消息响应函数，在里面处理

SetTimer是4个参数，你只有3个当然出错了第1个参数是接收WM_TIMER消息的窗口第2个参数是定时器的ID第3个参数是定时器的时间间隔，单位为毫秒第4个参数为定时器消息的处理函数，如果为NULL，则由第1个参数指定的窗口的消息处理函数来处理。 SetTimer(hwnd,1008,2000,NULL);//定时器ID为1008，间隔为2秒

If the function succeeds and the hWnd parameter is NULL, the return value is an integer identifying the new timer. An application can pass this value to the KillTimer function to destroy the timer.If the function succeeds and the hWnd parameter is not NULL, then the return value is a nonzero integer. An application can pass the value of the nIDEvent parameter to the KillTimer function to destroy the timer.If the function fails to create a timer, the return value is zero. To get extended error information, call GetLastError.第一个参数不为空，则用返回值作为nIDEvent。

#include "windows.h"#include "iostream"using namespace std;int n;void CALLBACK TimerProc(HWND hWnd, UINT nMsg, UINT nIDEvent, DWORD dwTime){ cout << n++ << endl;}int main(int argc, char* argv[]){ n = 0; UINT_PTR iTimerID = SetTimer(NULL, 0, 1000, TimerProc); MessageBox(NULL,TEXT("关闭"),TEXT("测试"),MB_OK); KillTimer(NULL, iTimerID); return 0;}

既然是在静态成员函数中创建，那么你想让这个定时器和哪个窗口关联呢？要么在静态成员中获得要关联的窗口对象（比如给类B添加一个静态成员当前窗口的指针 B* pWnd），然后调用pWnd->SetTimer(..)要么设置一个与窗口无关的全局Timer：::SetTimer(NULL,2,100, MyTimeProc);其中MyTimerProc是直接处理Timer消息的一个函数（不可以是类的非静态函数）：VOID CALLBACK MyTimerProc(HWND hwnd,UINT uMsg,UINT_PTR idEvent,DWORD dwTime){...}

添加WM_MOUSEMOVE 的消息，在函数OnMouseMove中添加代码：mouse_distance = sqrt((point.x - 200)*(point.x - 200) + (point.y - 200)*(point.y - 200));if(mouse_distance <= 250) {/*这里的1是Timer的标识，最好设置为WM_USER+一个常数，避免与程序的其他标识冲突*/ SetTimer(1,-3.96 * mouse_distance + 1000,NULL); }else KillTimer(1);//这里的1是上面Timer的标识。SetTimer使用已有的timer的标识创建的时候会自动killtimer，然后使用新的时间设置计时器。

全局SetTimer函数？你希望自己写消息，直接写VOID CALLBACK TimerProc( HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime);将这个函数作为全局，不就行了？ 回调函数是全局的，SetTimer可以是类内部的

void CHtmlDlgDlg::OnNowtime() //这里是你的按钮的话就这样写代码 { SetTimer(1,1000,NULL); }然后 ctrl+w 选择 WM_TIMER 消息void CHtmlDlgDlg::OnTimer(UINT nIDEvent) {CTime Time = CTime::GetCurrentTime(); strDigits.Format( "%d:%02d:%02d", Time.GetHour(), Time.GetMinute(), Time.GetSecond() ); GetDlgItem(IDC_NOWTIME)->SetWindowText("当前时间:"+strDigits); //一秒刷新 }这样就可以了 因为那个一秒显示需要放在TIMER事件下

如:settimer(hwnd,3,1000,NULL);.....KillTimer(hwnd,3);又如:Settimer(NULL,12,400,NULL);....Killtimer(NULL,12);可见Settimer的第二个参数是定时器的标识编号.销毁的时候只要killtimer选择标识就可以销毁相应那个编号的定时器.settimer第二参数是自己定义的,可以是随意的整数.

#include<stdio.h>#include<dos.h>#include<stdlib.h>#define ESC 0x11bvoid setTimer(int time){ int key=0; while(1){ printf("Hello World "); if(bioskey(1)) key=bioskey(0); if(key==ESC) break; sleep(time); }}void main(){ setTimer(1);}

的确是SetTimer API函数的第四个参数错误，第四个参数是回调函数 也就是指向了一个自身进程子程序的内存地址，对于这样的跨进程使用API，在这里是行不通的，如果想要使用SetTimer函数的话，就得DLL注入到进程中去了。至于 KillTimer函数，这个函数相对于上面的SetTimer函数参数要少，使用也就更简单。它没有回调函数，直接使用HWND就可以进行操控，至于第二个参数，也就是那个定时器的 序号，也是完全可以自由使用的。因此……

Windows提供了定时器，帮助编写定期发送消息的程序。定时器一般通过一下两中方式通知应用程序间隔时间已到。⑴ 给指定窗口发送WM_TIMER消息，也就是下面的给出在窗口类中使用的方法。⑵ 调用一个应用程序定义的回调函数，也就是在非窗口类中使用方法。4.1 在窗口类中使用定时器在窗口类中使用定时器比较简单。假如我们想让这个窗口上放置一个电子钟，这样我们必须每1秒或者0.5秒钟去更新显示显见。按照下面的步骤，就可以完成这个电子钟程序，并且知道如何在窗口类中使用定时器：首先做在我们新建项目的主窗口上添加一个Label控件，用来显示时间。接着⑴ 用函数SetTimer设置一个定时器，函数格式如下： UINT SetTimer( UINT nIDEvent,UINT nElapse,void (CALLBACK EXPORT* lpfnTimer)(HWND, UINT, UINT, DWORD));这个函数是CWnd类的一个成员函数，其参数意义如下：nIDEvent: 为设定的定时器指定的定时器标志值，设置多个定时器的时候，每个定时器的值都不同，消息处理函数就是通过这个参数来判断是哪个定时器的。这里我们设定为1。nElapse: 指定发送消息的时间间隔，单位是毫秒。这里我们设定为1000，也就是一秒。lpfnTimer: 指定定时器消息由哪个回调函数来执行，如果为空，WM_TIMER将加入到应用程序的消息队列中，并由CWnd类来处理。这里我们设定为NULL。最后代码如下：SetTimer(1,1000,NULL);⑵ 通过Class Wizard给主窗口类添加一个WM_TIMER消息的映射函数,默认为OnTimer(UINT nIDEvent)。⑶ 然后我们就可以在OnTimer(UINT nIDEvent)的函数实现中添加我们的代码了。参数nIDEvent就是我们先前设定定时器时指定的标志值，在这里我们就可以通过它来区别不同的定时器，而作出不同的处理。添加的代码如下：switch(nIDEvent){case 1:CTime m_SysTime = CTime::GetCurrentTime();SetDlgItemText(IDC_STATIC_TIME,m_SysTime.Format("%Y年%m月%d日 %H:%M:%S"));break;}代码中的IDC_STATIC_TIME就是我们先前添加的Label控件的ID。至此，我们的电子钟的程序就完成了。4.2 在非窗口类中使用定时器在非窗口类中使用定时器就要用到前面我们介绍到的所有知识了。因为是无窗口类，所以我们不能使用在窗口类中用消息映射的方法来设置定时器，这时候就必须要用到回调函数。又因为回调函数是具有一定格式的，它的参数不能由我们自己来决定，所以我们没办法利用参数将this传递进去。可是静态成员函数是可以访问静态成员变量的，因此我们可以把this保存在一个静态成员变量中，在静态成员函数中就可以使用该指针，对于只有一个实例的指针，这种方法还是行的通的，由于在一个类中该静态成员变量只有一个拷贝，对于有多个实例的类，我们就不能用区分了。解决的办法就是把定时器标志值作为关键字，类实例的指针作为项，保存在一个静态映射表中，因为是标志值是唯一的，用它就可以快速检索出映射表中对应的该实例的指针，因为是静态的，所以回调函数是可以访问他们的。首先介绍一下用于设置定时的函数：UINT SetTimer(HWND hWnd, // handle of window for timer messagesUINT nIDEvent, // timer identifierUINT uElapse, // time-out valueTIMERPROC lpTimerFunc // address of timer procedure);其中的参数意义如下：hWnd: 指定与定时器相关联的窗口的句柄。这里我们设为NULL。nIDEvent: 定时器标志值，如果hWnd参数为NULL，它将会被跳过，所以我们也设定为NULL。uElapse: 指定发送消息的时间间隔，单位是毫秒。这里我们不指定，用参数传入。lpTimerFunc: 指定当间隔时间到的时候被统治的函数的地址，也就是这里的回调函数。这个函数的格式必须为以下格式：VOID CALLBACK TimerProc(HWND hwnd, // handle of window for timer messagesUINT uMsg, // WM_TIMER messageUINT idEvent, // timer identifierDWORD dwTime // current system time);其中的参数意义如下：hwnd: 与定时器相关联的窗口的句柄。uMsg: WM_TIMER消息。idEvent: 定时器标志值。deTime: 系统启动后所以经过的时间，单位毫秒。最后设定定时器的代码为：m_nTimerID = SetTimer(NULL,NULL,nElapse,MyTimerProc);先通过Class Wizard创建一个非窗口类，选择Generic Class类类型，类名称为CMyTimer，该类的作用是每隔一段时间提醒我们做某件事情，然后用这个类创建三个实例，每个实例以不同的时间间隔提醒我们做不同的事情。MyTimer.h#includeclass CMyTimer;//用模板类中的映射表类定义一种数据类型typedef CMap CTimerMap;class CMyTimer{public://设置定时器，nElapse表示时间间隔，sz表示要提示的内容void SetMyTimer(UINT nElapse,CString sz);//销毁该实例的定时器void KillMyTimer();//保存该实例的定时器标志值UINT m_nTimerID;//静态数据成员要提示的内容CString szContent;//声明静态数据成员，映射表类，用于保存所有的定时器信息static CTimerMap m_sTimeMap;//静态成员函数，用于处理定时器的消息static void CALLBACK MyTimerProc(HWND hwnd,UINT uMsg,UINT idEvent,DWORD dwTime);CMyTimer();virtual ~CMyTimer();};MyTimer.cpp#include "stdafx.h"#include "MyTimer.h"//必须要在外部定义一下静态数据成员CTimerMap CMyTimer::m_sTimeMap;CMyTimer::CMyTimer(){m_nTimerID = 0;}CMyTimer::~CMyTimer(){}void CALLBACK CMyTimer::MyTimerProc(HWND hwnd,UINT uMsg,UINT idEvent,DWORD dwTime){CString sz;sz.Format("%d号定时器：%s",idEvent,m_sTimeMap[idEvent]->szContent);AfxMessageBox(sz);}void CMyTimer::SetMyTimer(UINT nElapse,CString sz){szContent = sz;m_nTimerID = SetTimer(NULL,NULL,nElapse,MyTimerProc);m_sTimeMap[m_nTimerID] = this;}void CMyTimer::KillMyTimer(){KillTimer(NULL,m_nTimerID);m_sTimeMap.RemoveKey(m_nTimerID);}这样就完成了在非窗口类中使用定时器的方法。以上这些代码都在Windwos 2000 Professional 和 Visual C++ 6.0中编译通过。

OnTimer响应函数是在按钮响应函数完成之后才开始响应的：按钮响应函数：SetTimer(1,1000,NULL); Sleep(5000); SetDlgItemText(IDC_EDIT1,"abc");OnTimer函数：void CTimeDlg::OnTimer(UINT nIDEvent) { SetDlgItemText(IDC_EDIT2,"def"); CDialog::OnTimer(nIDEvent);}可以看到都在5秒钟之后才用反应

SetTimer用到了windows的消息机制，在MFC程序中，新建工程就会帮你把消息机制的架子搭好。但是如果控制台程序要使用的话势必要自己把消息处理的各个环节都考虑进去，所以代码像楼上那样会很多很多。以简便的原则，可以CreateThread创建线程，在线程处理函数里面while（true）循环，每次循环输出一个字符，然后Sleep（2000）就有你预想的效果了。

Timer事件，即定时器事件，是在游戏编程中，经常使用的一个事件。借助它可以产生定时执行动作的效果。这篇文章，就和大家一起探讨一下如何使用SetTimer（）函数。 1、SetTimer定义在那里？ SetTimer表示的是定义个定时器。根据定义指定的窗口，在指定的窗口（CWnd）中实现OnTimer事件，这样，就可以相应事件了。SetTimer有两个函数。一个是全局的函数::SetTimer()UINT SetTimer( HWND hWnd, // handle of window for timer messages UINT nIDEvent, // timer identifier UINT uElapse, // time-out value TIMERPROC lpTimerFunc // address of timer procedure); 其中hWnd 是指向CWnd的指针，即处理Timer事件的窗口类。说道窗口类（CWnd），我们有必要来看一下CWnd的继承情况：CWnd有以下子类：CFrameWnd,CDialog,CView,CControlBar等类。这也意味这些类中都可以定义SetTimer事件。同时，SetTimer（）在CWnd中也有定义，即SetTimer（）是CWnd的一个成员函数。CWnd的子类可以调用该函数，来设置触发器。 UINT SetTimer( UINT nIDEvent, UINTnElapse, void (CALLBACK EXPORT* lpfnTimer)(HWND, UINT, UINT, DWORD) );参数含义： nIDEvent:是指设置这个定时器的iD，即身份标志，这样在OnTimer（）事件中，才能根据不同的定时器，来做不同的事件响应。这个ID是一个无符号的整型。 nElapse是指时间延迟。单位是毫秒。这意味着，每隔nElapse毫秒系统调用一次Ontimer（）。 void (CALLBACK EXPORT* lpfnTimer)(HWND, UINT, UINT, DWORD)Specifies the address of the application-suppliedTimerProc callback function that processes theWM_TIMER messages. If this parameter is NULL, theWM_TIMER messages are placed in the application"s message queue and handled by theCWnd object。 意思是，指定应用程序提供的TimerProc回调函数的地址，来处里这个Timer事件。如果是NULL，处理这个Timer事件的定义这个Timer的CWnd对象。他将WM_TIMER消息传递给这个对象，通过实现这个对象的OnTimer（）事件来处理这个Timer事件。所以，一般情况下，我们将这个值设为NULL，有设置该定时器的对象中的OnTimer（）函数来处理这个事件。同样的，我们再看看KillTimer（）和OnTimer（）的定义:KillTimer同SetTimer（）一样，他也有两个，一个是全局的::KillTimer(),另一个是CWnd的一个函数。他的声明如下： //全局函数BOOL KillTimer( HWND hWnd, // handle of window that installed timer UINT uIDEvent // timer identifier);//CWnd函数BOOL KillTimer( int nIDEvent);这两个函数表示的意思是将iD为nIDEVENT的定时器移走。使其不再作用。其用法如同SetTimer（）一样。再看看OnTimer（）CWnd::OnTimer afx_msg void OnTimer( UINT nIDEvent);ontimer（）是响应CWnd对象产生的WM_Timer消息。nIDEvent表示要响应TIMER事件的ID。 二、Timer事件的使用：由以上的分析，我们应该很清楚，如何来使用Timer事件。假定我们在视图上画一个渐变的动画。我们首先在菜单栏上添加一个菜单项，给这个菜单添加命令响应：pView->SetTimer(1,1000,NULL);//pView是视图类的指针，这里是在视图类当中设置一个定时器。添加完毕，再给视图类添加一个WM_Timer事件的相应。在OnTimer（）函数中编写汉书，进行相应。如此，就能做出动画。SetTimer(1,1000,NULL);//1为定时器的ID 1000为他的执行毫秒 最后一个通常为NULLVC6.0：建立类向导-找到你当前的XXXXDlg类 找到WM_TIMER 点add那个按钮 再点Edit按钮[就是add下面的]就会进一个代码区 别动 然后把中间的那句绿色的TODO什么的去掉 写：if(nidevent == 1)//判断那个定时器的ID{ a++;}1表示定时器的ID，1000表示没1000ms也就是1s调用一次处理函数，最后一个参数是处理的函数，如果填NULL表示，使用系统默认的，默认处理函数是OnTimer（）那个函数，在这里面写你要执行的操作就可以了，如果你有多个定时器要在这里写if(id == 1)类似的东西去区分不同的定时器，更换贴图最好是在OnTimer里面更换当前显示的图片编号，然后刷新界面，更换图片的工作让OnPaint去做，让他们各司其职。关闭定时器：KillTimer（1）启动计时器 UINT ID_TIMER1 = 1 , ID_TIMER2 = 2 //设置id 然后再你需要的时机依次启动各个计时器： SetTimer(ID_TIMER1 , 300); …… SetTimer(ID_TIMER2 , 400); …… …… OnTimer函数中这样写： void CMyClass::OnTimer(UINT nIDEvent) { switch(nIDEvent) { case ID_TIMER1: // id为1的计时器要做的事。 …… break; case ID_TIMER2: //id为2的计时器要做的事。 …… break; …… …… } } 一 SetTimer函数的用法1） 函数原型及变形SetTimer这个API函数的原型 ：UINT_PTR SetTimer(HWND hWnd, // 窗口句柄UINT_PTR nIDEvent, // 定时器ID，多个定时器时，可以通过该ID判断是哪个定时器UINT uElapse, // 时间间隔,单位为毫秒TIMERPROC lpTimerFunc // 回调函数);注意：设置第二个参数时要注意，如果设置的等待时间比处理时间短，程序就会出问题了。回调函数：在这个函数里，放入你想要做的事情的代码，你可以将它设定为NULL，也就是使用系统默认的回调函数，系统默认认的是onTime函数。例如 ：SetTimer(m_hWnd,1,1000,NULL); //一个1秒触发一次的定时器在MFC程序中SetTimer被封装在CWnd类中，调用就不用指定窗口句柄了于是SetTimer函数的原型变为：UINT SetTimer(UINT nIDEvent,UINT nElapse,void(CALLBACK EXPORT *lpfnTimer)(HWND,UINT ,YINT ,DWORD)) ，用法如：SetTimer(1,1000,NULL);2）函数生成方法在ClassWizard里，选择需要计时器的类，添加WM_TIME消息映射，就自动生成onTime函数了。然后在函数里添加代码，让代码实现功能。每隔一段时间就会自动执行一次。3） 回调函数的格式void CALLBACK TimerProc(HWND hWnd,UINT nMsg,UINT nTimerid,DWORD dwTime);二. 多个Timer把ID的值设为〉1的数，如：SetTimer(3,500,NULL);由WINDOWS会协调他们的然onTimer函数要在函数体内添加每一个timer的处理代码：onTimer(nIDEvent){switch(nIDEvent){case 1:........;break;case 2:.......;break;case 3:......;break;}三、KillTimer：取消定时器不再使用定时器后，我们应该调用KillTimer来取消定时。 KillTimer的原型： BOOL KillTimer(HWND hWnd, // 窗口句柄 UINT_PTR uIDEvent // ID); 在MFC程序中我们可以直接调用KillTimer(int nIDEvent)来取消定时器什么时候我们需要用到SetTimer函数呢？当你需要每个一段时间执行一件事的的时候就需要使用SetTimer函数了。 使用定时器的方法比较简单，通常告诉WINDOWS一个时间间隔，然后WINDOWS以此时间间隔周期性触发程序。通常有两种方法来实现：发送WM_TIMER消息和调用应用程序定义的回调函数。1.1 用WM_TIMER来设置定时器先请看SetTimer这个API函数的原型UINT_PTR SetTimer( HWND hWnd, // 窗口句柄 UINT_PTR nIDEvent, // 定时器ID，多个定时器时，可以通过该ID判断是哪个定时器 UINT uElapse, // 时间间隔,单位为毫秒 TIMERPROC lpTimerFunc // 回调函数);例如 SetTimer(m_hWnd,1,1000,NULL); //一个1秒触发一次的定时器在MFC程序中SetTimer被封装在CWnd类中，调用就不用指定窗口句柄了于是SetTimer函数的原型变为：UINT SetTimer(UINT nIDEvent,UINT nElapse,void(CALLBACK EXPORT *lpfnTimer)(HWND,UINT ,YINT ,DWORD))当使用SetTimer函数的时候，就会生成一个计时器。函数中nIDEvent指的是计时器的标识，也就是名字。nElapse指的是时间间隔，也就是每隔多长时间触发一次事件。第三个参数是一个回调函数，在这个函数里，放入你想要做的事情的代码，你可以将它设定为NULL，也就是使用系统默认的回调函数，系统默认认的是onTime函数。这个函数怎么生成的呢？你需要在需要计时器的类的生成onTime函数：在ClassWizard里，选择需要计时器的类，添加WM_TIME消息映射，就自动生成onTime函数了。然后在函数里添加代码，让代码实现功能。每隔一段时间就会自动执行一次。例：SetTimer(1,1000,NULL);1:计时器的名称；1000：时间间隔，单位是毫秒；NULL:使用onTime函数。当不需要计时器的时候调用KillTimer(nIDEvent);例如：KillTimer(1);1.2 调用回调函数此方法首先写一个如下格式的回调函数void CALLBACK TimerProc(HWND hWnd,UINT nMsg,UINT nTimerid,DWORD dwTime);然后再用SetTimer(1,100,TimerProc)函数来建一个定时器，第三个参数就是回调函数地址。二. 或许你会问，如果我要加入两个或者两个以上的 timer怎么办？继续用SetTimer函数吧，上次的timer的ID是1，这次可以是2，3，4。。。。SetTimer(2,1000,NULL);SetTimer(3,500,NULL);嗯，WINDOWS会协调他们的。当然onTimer函数体也要发生变化，要在函数体内添加每一个timer的处理代码：onTimer(nIDEvent){switch(nIDEvent){case 1:........;break;case 2:.......;break;case 3:......;break;}}你在OnTimer里，先计算，然后Invalidate了，这样做很不错，可进入Draw里，又让Draw负责椭圆的计算工作，是不是应该这样做：1）定义个CRect m_rectEllipse;2）在OnTimer中计算m_rectEllipse，在按键按下时也可以计算这个m_rectEllipse。3）在Draw里只负责画椭圆，其他都不做。4）程序还有可以改进的地方，如闪屏会出现吗？定时器分辨率较高时应该会吧！呵呵，说下去一大堆了。P.S.把程序模块调整一下，然后立刻就能发现问题所在了，很好找。首先在这里说一下，我使用的环境是VS2005。先说一下步骤，然后贴出代码。步骤1：建立基于Dialog的MFC工程；步骤2：在对话框上添加两个静态框，分别为“1秒中刷新一次”和“2秒刷新一次” 。两个编辑框，分别为“IDC_EDIT1”和"IDC_EDIT2"，默认情况下就是这样的。然后在对应的对话框类中添加两个成员变量：m_nData1 和 m_nData2然后把编辑框的ReadOnly都改为TRUE 。步骤3：点击OK按钮，在其中添加代码，如下：[html] view plaincopyprint?void CMFCTimerDlg::OnBnClickedOk() { // TODO: Add your control notification handler code here SetTimer(1, 2000, NULL) ; SetTimer(2, 1000, NULL) ; //OnOK(); } 步骤4：对话框类添加WM_TIME消息。代码如下：[html] view plaincopyprint?void CMFCTimerDlg::OnTimer(UINT_PTR nIDEvent) { // TODO: Add your message handler code here and/or call default switch(nIDEvent) { case 1: if (5 == m_nData1) { KillTimer(1) ; break ; } SetDlgItemInt(IDC_EDIT1, ++m_nData1) ; case 2: if (10 == m_nData2) { KillTimer(2) ; break ; } SetDlgItemInt(IDC_EDIT2, ++m_nData2) ; default: break ; } CDialog::OnTimer(nIDEvent); }

问题1：两种方法都可以，如果给SetTimer的最后一个参数传入NULL，需要添加WM_TIMER消息映射，让VC自动生成OnTimer函数；如果传入一个回调函数地址，系统就会调用你写的回调函数。除了写法略有不同，二者几乎没啥区别的。如果你要设置多个计时器，如果使用OnTimer函数，需要在其内部区分计时器ID值；如果使用回调函数，可以为每个定时器传入不同的回调函数，这就它们的区别。问题2：如果使用OnTimer函数，必须在窗口类内部添加WM_TIMER消息映射，并在窗口类内部实现OnTimer进行消息响应。如果使用回调函数，这个函数可以是全局的。回调函数的声明可以是这样：voidCALLBACKMyTimerProc(HWNDhWnd,UINTnMsg,UINTnIDEvent,DWORDdwTime)参数1是设置定时器的窗口句柄，参数2是消息类型，也就是WM_TIMER，参数3是定时器ID，参数4是时间延迟。你的程序没有创建窗口，不能使用定时器，定时器是依赖于窗口消息的，你必须指定一个处理WM_TIMER消息的窗口。

总的来说, 这里面一共需要三个函数:SetTimer, KillTimer()和OnTimer(). 先请看SetTimer这个API函数的原型UINT_PTR SetTimer( HWND hWnd, // 窗口句柄 UINT_PTR nIDEvent, // 定时器ID，多个定时器时，可以通过该ID判断是哪个定时器 UINT uElapse, // 时间间隔,单位为毫秒 TIMERPROC lpTimerFunc // 回调函数);例如SetTimer(m_hWnd,1,1000,NULL); //一个1秒触发一次的定时器在MFC程序中SetTimer被封装在CWnd类中，调用就不用指定窗口句柄了于是SetTimer函数的原型变为：UINT SetTimer(UINT nIDEvent,UINT nElapse,void(CALLBACK EXPORT *lpfnTimer)(HWND,UINT ,YINT ,DWORD))当使用SetTimer函数的时候，就会生成一个计时器。函数中nIDEvent指的是计时器的标识，也就是名字。nElapse指的是时间间隔，也就是每隔多长时间触发一次事件。第三个参数是一个回调函数，在这个函数里，放入你想要做的事情的代码，你可以将它设定为NULL，也就是使用系统默认的回调函数，系统默认认的是onTime函数。这个函数怎么生成的呢？你需要在需要计时器的类的生成onTime函数：在ClassWizard里，选择需要计时器的类，添加WM_TIME消息映射，就自动生成onTime函数了。然后在函数里添加代码，让代码实现功能。每隔一段时间就会自动执行一次。例：SetTimer(1,1000,NULL);1:计时器的名称；1000：时间间隔，单位是毫秒；NULL:使用onTime函数。当不需要计时器的时候调用KillTimer(nIDEvent);

仅供参考：1、添加WM_TIMER消息响应2、SetTimer(1,1000,NULL)3、函数OnTimer中处理

例如SetTimer(m_hWnd,1,1000,NULL); //一个1秒触发一次的定时器在MFC程序中SetTimer被封装在CWnd类中，调用就不用指定窗口句柄了于是SetTimer函数的原型变为：UINT SetTimer(UINT nIDEvent,UINT nElapse,void(CALLBACKEXPORT *lpfnTimer)(HWND,UINT ,YINT ,DWORD))当使用SetTimer函数的时候，就会生成一个计时器。SetTimer函数中nIDEvent指的是计时器的标识，也就是名字。nElapse指的是时间间隔，也就是每隔多长时间触发一次事件。第三个参数是一个回调函数，在这个函数里，放入你想要做的事情的代码，你可以将它设定为NULL，也就是使用系统默认的回调函数，系统默认的是OnTime函数。这个函数怎么生成的呢？你需要在需要计时器的类的生成onTime函数：在ClassWizard里，选择需要计时器的类，添加WM_TIME消息映射，就自动生成OnTime函数了。然后在函数里添加代码，让代码实现功能。每隔一段时间（SetTimer设置的时间）就会自动执行一次。例：SetTimer(1,1000,NULL);1:计时器的名称；1000：时间间隔，单位是毫秒；NULL:使用onTime函数。当不需要计时器的时候调用KillTimer(nIDEvent);例如：KillTimer(1); //此处的ID号“1 ”应与SetTimer()中的ID号一致如果需要要加入两个或者两个以上的timer怎么办？继续用SetTimer函数吧，上次的timer的ID是1，这次可以是2，3，4......SetTimer(2,1000,NULL); //ID为2，定时1000msSetTimer(3,500,NULL); //ID为3，定时500msWINDOWS会协调他们的。当然OnTimer函数体也要发生变化，要在函数体内添加每一个timer的处理代码：OnTimer(nIDEvent){switch(nIDEvent){case 1:........;break;case 2:.......;break;case 3:......;break;}}在控制台中使用定时器不能简单的SetTimer了事，这在控制台里这种SetTimer的方式是有点麻烦的，需要自己写消息循环投递WM_TIMER消息。其实在控制台里可以使用多媒体时钟来计时：example://启动计时器MMRESULT nIDTimerEvent = timeSetEvent(1000,//延时1秒0,TimeProc,0,(UINT)TIME_PERIODIC);if( nIDTimerEvent == 0 )cout<<启动计时器失败<<endl;//回调过程（时钟到来，回调函数被系统自动调用）void CALLBACK TimeProc(UINT uID,UINT uMsg,DWORD dwUser,DWORD dw1,DWORD dw2){cout<<时钟到来<<endl;}当然了，你要是习惯于SetTimer，那就用SetTimer吧：下面是我在Console下用SetTimer写的一个例子：#include <windows.h>#include <iostream>using namespace std;void CALLBACK TimeProc(HWND hwnd,UINT message,UINT idTimer,DWORD dwTime);int main(){SetTimer(NULL,1,1000,TimeProc);MSG msg;while(GetMessage(&msg,NULL,0,0)){if(msg.message==WM_TIMER){DispatchMessage(&msg);}}return 0;}void CALLBACK TimeProc(HWND hwnd,UINT message,UINT idTimer,DWORD dwTime){cout<<a timer comming<<endl;}

void main() { int h,m,s; struct time now; gettime(&now); printf("the current time is %d:%d:%d ",now.ti_hour,now.ti_min,now.ti_sec); //.....now.ti_hour++;//小时加1printf("the current time is %d:%d:%d ",now.ti_hour,now.ti_min,now.ti_sec);settime (&now); //.....gettime (&now); printf("the current time is %d:%d:%d ",now.ti_hour,now.ti_min,now.ti_sec); }

你好，关于你的问题，我也不太清楚原因，所以我也尝试着去写了一个程序验证一下，结果并没有出现你所说的情况。代码几乎跟你一样。而对于gww1bd 的回答，我则不同意，MSDN里有讲到如果第一个参数是空的，则第二个参数会被忽略。而我又看到这么一段话：When you specify a TimerProc callback function, the default window procedure calls the callback function when it processes WM_TIMER. Therefore, you need to dispatch messages in the calling thread, even when you use TimerProc instead of processing WM_TIMER. 你可以尝试着去调用LRESULT DispatchMessage( CONST MSG *lpmsg // message information);If the lpmsg parameter points to a WM_TIMER message and the lParam parameter of the WM_TIMER message is not NULL, lParam points to a function that is called instead of the window procedure. 你先试试 ，不行的话再联系我。

您好，这样的：因为,在调用构造函数时对话框还没有初始化,此时的SetTimer对对话框无效,只有在对话框进行初始化时才能设定其定时器,或者在对话框初始化后SetTimer()也行。不要在构造函数中SetTimer，你如果一定要自动执行的化可以在OnInitDialog或OnShowWindow下面做。还有就是100毫秒这个参数会使OnTimer下的程序在1秒种执行10次，你在里面放一个MessageBox是不是太。另外，如果你要试一下它到底有没有执行的话，可以把SetTimer的参数设大一点，比如2000然后用AfxMessageBox 不可你要做好快速反应结束程序的准备，要不然会有。

如果我要加入两个或者两个以上的 timer怎么办？ 　　继续用SetTimer函数吧，上次的timer的ID是1，这次可以是2，3，4。。。。 　　SetTimer(2,1000,NULL); 　　SetTimer(3,500,NULL); 　　嗯，WINDOWS会协调他们的。当然onTimer函数体也要发生变化，要在函数体内添加每一个timer的处理代码： 　　onTimer(nIDEvent) 　　{ 　　switch(nIDEvent) 　　{ 　　case 1:........; 　　break; 　　case 2:.......; 　　break; 　　case 3:......; 　　break; 　　} 　　} 　　Timer事件，即定时器事件，是在游戏编程中，经常使用的一个事件。借助它可以产生定时执行动作的效果。这篇文章，就和大家一起探讨一下如何使用SetTimer（）函数。

SetTimer(NULL, 1, 5000, timerproc)表示定时器标志符为1（当你设置了多个Timer时，用来区别他们），每隔5000ms触发一个Timer事件，timerproc是你设置的回调函数。有两种处理方式：1.将回调函数设置为NULL，通过window中捕获WM_TIMER消息来处理。估计你使用的是MFC，所以对这个时间添加了处理函数，那就是OnTimer。就是说，每隔5000ms就会调用OnTimer函数。SetTimer(NULL, 1, 5000, NULL)2.也可以通过回调函数来处理，这个回调函数就是你写的timerproc。这时就会每隔5000ms调用timerproc了。SetTimer(NULL, 1, 5000, timerproc)KillTimer就是不想定时触发事件了或者说不在需要定时器了，用来删除定时器的KillTimer(1)就是将标志位1的Timer删除。

你给IDC_EDIT1关联一个UINT变量，假设为m_editVal;，然后响应按钮消息，在按钮消息响应函数里：UpdateData(TRUE);SetTimer(1, m_editVal, NULL);参数依次为:定时器号，定时时间(毫秒),定时回调函数。如果你要在时间到了以后响应自己的函数，就需要设定第三个参数，否则就添加消息响应WM_TIMER，然后在里面判断函数参数只有一个，就是定时器编号，如上设定定时器1，那你就得判断参数是否为1，如果是，那就是定时时间到了。还有不懂的，欢迎追问。

这个函数是定时器函数有四个参数，全部是传入参数，第一个数窗口句柄，第二个是定时器ID，第三个是定时器时间，就是多久触发一次ontimer函数，最后一个是回调函数，可以为null。