精华内容
下载资源
问答
  • DWORD WINAPI

    万次阅读 2014-11-27 14:23:18
    DWORD WINAPI Zhaa(LPVOID PP) 查看WINAPI的定义,它是这样定义的 #define WINAPI _stdcall 可以发现CALLBACK也是这样定义的 _stdcall规定了编译时的一些选项WINAPI是一个宏,所代表的符号是__stdcall, 函数名前...
    DWORD WINAPI Zhaa(LPVOID PP)	   
    查看WINAPI的定义,它是这样定义的
    #define WINAPI _stdcall
    可以发现CALLBACK也是这样定义的
    _stdcall规定了编译时的一些选项
    WINAPI是一个宏,所代表的符号是__stdcall, 函数名前加上这个符号表示这个函数的调用约定是标准调用约定,windows API函数采用这种调用约定。
    
    
    
    int winapi winmain()
    #define WINAPI       __stdcall
    具体来说,他们是关于堆栈的一些说明,首先是函数参数压栈顺序,其次是压入堆栈的内容由谁来清除,调用者还是函数自己?
    stdcall的调用约定意味着: 
    1)参数从右向左压入堆栈;
    2)函数自身修改堆栈;
    3)函数名自动加前导的下划线,后面紧跟一个@符号,其后紧跟着参数的尺寸。

    展开全文
  • DWORD WINAPI 函数名

    千次阅读 2017-07-05 09:29:00
    DWORD WINAPI 函数名: 这个是Windows编程中要了解的,首先DWORD是数据类型,在这里是返回值,WINAPI是函数的调用形式,最终就是_stdcall形式,就被调用函数来清理栈中的参数,这种形式是不能实现可变参数的。 ...

    http://ask.csdn.net/questions/153821

    DWORD WINAPI 函数名:

       这个是Windows编程中要了解的,首先DWORD是数据类型,在这里是返回值,WINAPI是函数的调用形式,最终就是_stdcall形式,就被调用函数来清理栈中的参数,这种形式是不能实现可变参数的。

      windows api = windows application programming interface = windows 应用程序编程接口。

      WINAPI:

    #define WINAPI _stdcall
    WINAPI是个宏,一般会被代换为一个调用约定,通常为_stdcall,告诉编译器如何调用该函数。

    http://www.cnblogs.com/youlin/p/macro_WINAPI_and_call_convention.html
    具体请搜索:调用约定 WINAPI

    转载于:https://www.cnblogs.com/pureyes-cyl/p/7119575.html

    展开全文
  • 函数原型是:DWORD (WINAPI* m_pfnGetInfo)(int nInfo, void* pBuf); 2个动态库,原来用BCB写的,没问题, C++ BULIDER中这样: extern "C" __declspec(dllexport) DWORD WINAPI GetInfo(int nInfo,void * pBuf) VC...
  • 在用C语言编写网络时经常会有这些看不懂的,结构,函数。这应该看什么书补充这方面的知识呢?
  • 急救!多线程调用的函数传入参数以后怎样能在主函数中再次访问这个参数?即DWORD WINAPI time(LPVOID lp) 是否如果我传的是参数指针,那么就可以在主函数中再次访问?
  • c++利用winapi实现简单多线程

    千次阅读 2016-11-10 15:33:02
    #include<windows.h> #include<iostream> #include&...DWORD WINAPI FUN1Proc(LPVOID lpParameter); //线程函数入口 DWORD WINAPI FUN2Proc(LPVOID lpParameter); int in...
    #include<windows.h>
    #include<iostream>
    #include<cstdlib>
    
    using namespace std;
    
    DWORD WINAPI FUN1Proc(LPVOID lpParameter); //线程函数入口
    DWORD WINAPI FUN2Proc(LPVOID lpParameter);
    
    int index=0;
    int tickets=100;
    int main()
    {
    	HANDLE hThread1,hThread2;
    	hThread1=CreateThread(NULL,0,FUN1Proc,NULL,0,NULL); //第一个参数,使用默认的安全性;第二个参数,使用与调用函数的线程相同的栈大小
    	hThread1=CreateThread(NULL,0,FUN2Proc,NULL,0,NULL); //第三个参数,线程函数入口;第四个参数,传递给线程的参数,第五个参数,线程创建后
    							    //立即运行,第六个参数,新线程的ID
    	
    	CloseHandle(hThread1);
    	CloseHandle(hThread2;
    	/* while(index++<1000)
    		cout<<"main thread is running"<<endl; */
    	//Sleep(10); //暂停当前线程的时间间隔
    	Sleep(4000);
    	return 0;
    }
    
    DWORD WINAPI FUN1Proc(LPVOID lpParameter)
    {
    	/* while(index++<1000)
    		cout<<"thread1 is runnning"<<endl; */
    	while(TRUE)
    	{
    		if(tickets>0)
    			cout<<"thread1 sell ticket:"<<ticket--<<endl;
    		else
    			break;
    	}
    	return 0;
    }
    
    DWORD WINAPI FUN2Proc(LPVOID lpParameter)
    {
    	/* while(index++<1000)
    		cout<<"thread2 is runnning"<<endl; */
    	while(TRUE)
    	{
    		if(tickets>0)
    			cout<<"thread2 sell ticket:"<<ticket--<<endl;
    		else
    			break;
    	}
    	return 0;
    }

    展开全文
  • 学习一个WinAPI实现的线程基类

    千次阅读 2015-11-16 00:49:44
    这个基类通过调用WinAPI的方法,编写了一个可以管理线程的基类,功能和用法都很基础,但是对...static DWORD WINAPI threadFunction(LPVOID); class Thread { friend DWORD WINAPI threadFunction(LPVOID); public:

    这个基类通过调用WinAPI的方法,编写了一个可以管理线程的基类,功能和用法都很基础,但是对理解线程的工作很有帮助。
    h文件:

    #include <windows.h>
    static DWORD WINAPI threadFunction(LPVOID);
    class Thread {
        friend DWORD WINAPI threadFunction(LPVOID);
    public:
        Thread();
        virtual ~Thread();
        int start(void * = NULL);
        void * wait();
        void stop();
        void detach();
        static void sleep(unsigned int);
    protected:
        virtual void * run(void *) = 0;
    private:
        HANDLE threadHandle;
        bool started;
        bool detached;
        void * param;
        unsigned int threadID;
    };

    cpp文件:

    //Thread的入口,返回int,接受void*,void*的实参在生成Thread时可以指认,这里在入口内调用了run,而run是一个纯虚函数
    //我们真正使用这个类时,实现run,以完成我们的目标
    DWORD WINAPI threadFunction(LPVOID object)
    {
        Thread * thread = (Thread *)object;
        return  (unsigned int)thread->run(thread->param);
    }
    
    //Thread的真正初始化都不是我们完成的,我们只是封装了windowsapi的接口
    //构造函数很简单,因为我们在start的时候才真正向Windows申请Thread
    Thread::Thread()
    {
        started = false;
        detached = false;
    }
    
    //析构是就是简单的停止进程
    Thread::~Thread()
    {
        stop();
    }
    
    //真创建Thread在这里,构造实例时,Thread还不存在
    int Thread::start(void* pra)
    {
        if (!started)
        {
            //真正要给Thread的run函数的实参
            param = pra;
            /*调用api的CreateThread函数创建Thread返回Thread句柄、Thread的ID
            参数:
            Thread安全flag,默认是NULL
            Thread的栈大小,0为默认值,表示和主Thread一致
            函数指针,指向Thread入口,必须返回DWORD,接受LPVOID,注意函数要加WINAPI修饰,不然这里穿不进去
            void*类型的一段内存,会被传到Thread入口函数作为参数,这里把自己传进去了,因为真正的实参在自己的实例里,是param
            其他控制flag,0表示没有
            返回DWORD的指认,是Thread的ID*/
            if (threadHandle = (HANDLE)CreateThread(NULL, 0, threadFunction, this, 0, (LPDWORD)&threadID))
            {
                //detached表示不和主Thread合流,一旦Thread运行完毕,自行销毁,主Thread也不会阻塞等待子Thread
                if (detached)
                {
                    //为什么要在start里释放Handle:
                    //Thread等等windows内核资源都是内核保存引用计数的,create的时候为某值(因为我们不知道Windows内部引用了几次)
                    //引用计数被引用时加一,被释放时减一
                    //但是注意!这里CloseHandle并不是对Thread进行了释放!而仅仅对句柄进行了释放
                    //如果对WindowsAPI有了解,就会明白,ThreadHandle和Thread本身根本就是两个对象
                    //Handle是对Thread的引用,会增加Thread的引用计数,但是释放Handle并不一定会导致Thread被释放
                    //毕竟释放一个Handle,只会是该Thread的计数减一,但是如果该Thread的入口函数还没有返回
                    //那么Windows内部对它还是有引用的,所以他不会被释放,仅仅是你因为没有了Handle
                    //失去了访问和控制他的接口,但是Thread依然会在自己完成任务之后自己销毁,因为那时候引用计数归零了
                    //但是如果恰恰相反,Thread入口函数返回,Windows内部已经把所有对其的引用释放了,就留着你这一个Handle没释放
                    //那么Thread的计数会一直维持在1,不能被释放,必须等到你释放了Handle,它才归零释放
                    //所以,所Handle和Thread的释放完全没有关系也是不对的,Handle仅仅是一个访问接口和一个引用源
                    //至于这里,如果detach,就释放Handle,是因为如果Thread工作于detach工作模式
                    //那么它不与调用他的Thread进行任何同步,即我们根本不需要控制它的完成时间,所以我们完全可以释放Handle
                    //不要对它的引用,让它自生自灭,这样该Thread入口函数返回之后,它自然就会销毁
                    CloseHandle(threadHandle);
                }
                started = true;
            }
        }
        return started;
    }
    
    //wait是等待到自己的Thread完成才会返回,不然阻塞调用他的Thread,注意,仅仅是阻塞调用他的Thread
    //所以你先wait a,后wait b,输出仍然可能是b先于a
    //因为a和b都没有阻塞,是main阻塞在a的wait处,并不影响a和b的先后顺序
    void * Thread::wait()
    {
        DWORD status = (DWORD)NULL;
        if (started && !detached)
        {
            //wait的核心语句,阻塞的实现就是这一句达到了,等待给出句柄对应的Thread完成(本质是有信号),不然阻塞INFINITE之后返回
            WaitForSingleObject(threadHandle, INFINITE);
            //获得一个已经退出线程的状态码,状态码是通过第二个参数WORD的长指针传出来的,非零表示成功,零表示失败
            GetExitCodeThread(threadHandle, &status);
            //通过了信号检测则说明Thread执行完成,这时候Thread入口函数已经完成,就剩一个引用计数,就是我们的Handle
            //我们释放我们的Handle,这样Thread才会释放,不然会一直占用资源而没有实际工作意义
            CloseHandle(threadHandle);
            detached = true;
        }
        return (void *)status;
    }
    
    //detach时,我们不管理Thread,让他自生自灭
    void Thread::detach()
    {
        if (started && !detached)
        {
            //直接释放Handle,Thread完成时,自然会销毁
            CloseHandle(threadHandle);
        }
        detached = true;
    }
    void Thread::stop()
    {
        if (started && !detached)
        {
            //强行关闭一个Thread,本方法的有几个要点:
            //1.这是个异步方法,即不能保证stop返回之后,Thread一定被释放
            //2.这个方法仅仅是Windows释放内核Thread的资源,我们这个Thread类实例还是存在的
            //3.这个释放是对Windows内核而言的,内核会释放所有对该Thread的应用,但是别忘了,还有我们的Handle指向它呢
            //如果不把指向它的Handle释放干净,这个Thread是不会释放的!没有删除方法能绕过引用计数的控制!
            //4.对该Thread的Terminate是强制的,该Thread无法知道自己要被Terminate了,所以也无法做任何保护措施,是十分危险的
            TerminateThread(threadHandle, 0);
            //释放我们的Handle,保证Thread的计数能归零,使它释放
            CloseHandle(threadHandle);
            detached = true;
        }
    }
    
    //休眠函数
    void Thread::sleep(unsigned int delay)
    {
        //调用WindowsAPI使本线程休眠
        Sleep(delay);
    }

    写了这么一堆注释,不如再搞个例程吧:

    class test :public Thread
    {
        virtual void* run(void* param)override;
    };
    
    void* test::run(void* param)
    {
        printf("%s\n", (char*)param);
        return param;
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        test a;
        test b;
        printf("%s\n", "test begin!");
        a.start("a is running");
        b.start("b is running");
        a.wait();
        b.wait();
        printf("%s\n", "main is over!");
        getchar();
        return 0;
    }

    输出还是比较好预测的:
    test begin!
    b is running
    a is running
    main is over!

    通过断点可以更好的的理解运行的顺序
    main->a.start->b.start->b.run->a.wait(卡在阻塞那一句)->a.run(a.wait结束阻塞)->b.wait(这次不阻塞了,因为b run过了)->return 0

    展开全文
  • SO_RCVTIMEO DWORD Sets the timeout, in milliseconds, for blocking receive calls. SO_SNDTIMEO DWORD The timeout, in milliseconds, for blocking send calls. </code></pre> <p>So there is a platform ...
  • C++学习笔记————WINAPI宏定义 在学习时,发现有一个代码...DWORD WINAPI Fun(LPVOID lpParamter) { for (int i = 0; i < 10; i++) cout << "A Thread Fun Display!" << endl; return 0L; } ...
  • INI文件名 配置文件.ini 请注意:我们所讨论的是项目中的配置文件,它是整个项目共用的。所以它要有一个项目使用的文件名,其后缀是.ini。例如:端口配置.ini 格式 ...DWORD WINAPI GetPrivateP...
  • WINAPI

    千次阅读 2009-08-21 09:25:00
    今天读程序的时候看到一个函数这样写:bool WINAPI ConsoleCtrlHandler(DWORD);对这个WINAPI的意思不太明白,就上网找了一些关于这个名词的解释。就当做做笔记了。 WINAPI的定义见windef.h这个头文件其定义是这样的...
  • DWORD WINAPI ThreadFunc(LPVOID lpParam) { HWND hwnd=(HWND)lpParam; //MessageBox(hwnd,"1","1",MB_OK); SetDlgItemText(hwnd,IDC_STATUS,"正在登陆"); Sleep(5000); //MessageBox(hwnd,
  • Win32 进程操作

    2021-04-19 06:08:17
    创建线程 #include<iostream> #include<windows.h>...DWORD WINAPI PROCESST1(LPVOID param); DWORD WINAPI PROCESST2(LPVOID param); DWORD WINAPI PROCESST3(LPVOID param); int ...
  • 自动重置事件练习

    2016-01-24 13:55:40
    #include "iostream" #include "windows.h" using namespace std;...DWORD WINAPI ThreadProc1(LPVOID lpParam); DWORD WINAPI MonitorProc(LPVOID pvContext); DWORD WINAPI CheckWindows(LPVOID pvVal); H
  • FILE* out_num; FILE* out_pic;  HANDLE hThread; // DWORD dwThread;  HANDLE hThread2; ...DWORD WINAPI NumSaveFile_proc(LPVOID lpParam);...DWORD WINAPI PicSaveFile_proc(LPVOID lpParam);...DWORD WINAPI
  • 3线程

    2014-11-02 11:19:59
    #include #include using namespace std; static int count1 = 1; DWORD WINAPI Fun1Proc(LPVOID lpParameter);//thread data ...DWORD WINAPI Fun2Proc(LPVOID lpParameter);...DWORD WINAPI Fun3
  • 创建一个线程过程数组,例如:DWORD WINAPI myThreadProcA(LPVOID p){DWORD dw =(DWORD)p; return dw;} DWORD WINAPI myThreadProcB(LPVOID p){DWORD dw =(DWORD)p; return dw * dw;}无效的CreateMyThreads...
  • 1、自动重置事件对象。 #include #include ...DWORD WINAPI Fun1Proc(LPVOID lpParameter); DWORD WINAPI Fun2Proc(LPVOID lpParameter); DWORD WINAPI Fun3Proc(LPVOID lpParameter); HANDL
  • 多线程-5

    2014-04-29 22:39:55
    #include #include //using namespace std;...DWORD WINAPI Fun1Proc( LPVOID lpParameter // thread data ); DWORD WINAPI Fun2Proc( LPVOID lpParameter // thread data ); int index=0; int tickets=100;
  • 多线程-4

    2014-04-29 21:57:05
    多线程-卖票 #include #include //using namespace std;...DWORD WINAPI Fun1Proc( LPVOID lpParameter // thread data ); DWORD WINAPI Fun2Proc( LPVOID lpParameter // thread data ); int index=0; int tic
  • win32 多线程基础

    千次阅读 2013-01-16 22:10:07
    // MultiThead.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include using namespace std; DWORD WINAPI Fun1Proc( LPVOID lpParameter //thread data ...DWORD WINAPI
  • 1、修复重定向表的时候为了计算函数偏移,并兼容64位和32位,我把函数指针转为DWORD_PTR后计算 !... ...2、75行这句赋值右边强转后的值是正常的 ...DWORD WINAPI ShowDialog(LPARAM lp_data); ```
  • // Mutex.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include ...DWORD WINAPI ThreadFun1(LPVOID); DWORD WINAPI ThreadFun2(LPVOID); DWORD WINAPI ThreadFun3(LPVOID); int
  • [Win32]C++多线程编程实例

    千次阅读 2012-11-12 11:43:14
      //这是2个线程模拟卖火车票的小程序 #include #include using namespace std; DWORD WINAPI Fun1Proc(LPVOID lpParameter);//thread data DWORD WINAPI Fun2Pro
  • windows进程函数介绍【一】

    千次阅读 2013-02-17 10:27:36
    GetCurrentProcessId Function Retrieves the process identifier of the calling process. Syntax ...DWORD WINAPI GetCurrentProcessId(void);...DWORD WINAPI GetCurrentProcess
  • 多线程

    2012-02-04 12:15:00
    一个简单的多线程程序#include <Windows.h> #include <iostream> using namespace std; ...DWORD WINAPI Fun1Proc(LPVOID lpParameter);...DWORD WINAPI Fun2Proc(LPVOID ...DWORD WINAPI Fun3Proc(L...
  • 7月24日

    2013-07-24 20:14:17
    线程练习 1.创建三个线程,线程1每隔1秒发送一个信号,奇数次线程2...DWORD WINAPI Thread1(LPVOID lpParam); DWORD WINAPI Thread2(LPVOID lpParam); DWORD WINAPI Thread3(LPVOID lpParam); HANDLE m_event,m_even
  • 1. 互斥量,Mutex #include #include using namespace std; DWORD WINAPI Thread1(LPVOID lpParmeter); DWORD WINAPI Thread2(LPVOID lpParmeter); static HANDLE g_hMutex = INV
  • #include "stdafx.h" #include #include #include HANDLE g_hMutex = NULL; const int g_Number = 3;...DWORD WINAPI ThreadProc1(LPVOID lpParam); DWORD WINAPI ThreadProc2(LPVOID lpParam); DWORD WIN
  • 第15讲 c++多线程

    千次阅读 2011-07-05 23:48:27
    #include #include using namespace std; DWORD WINAPI ThreadOne(LPVOID lpParameter); DWORD WINAPI ThreadTwo(LPVOID lpParameter); in

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,823
精华内容 1,129
关键字:

dwordwinapi