Visual C++下的C/C++编程主要包括Win32控制台程序、Win32应用程序以及MFC应用程序，当然还可以编写Win32和MFC程序库。Win32控制台程序和Win32应用程序的区别在于链接时指定的/subsystem选项不同，Win32控制台程序链接时/subsystem选项指定的是/subsystem:console，而Win32应用程序链接时/subsystem选项指定的是/subsystem:windows。至于MFC应用程序，严格来说，这并不是一种应用程序类型，MFC全称为“Microsoft Foundation Class (MFC) Library”，这个其实只是一个库，或者说是一个编程框架。不管是开发Win32控制台程序还是Win32应用程序，都可以像引入一个第三方库一样引入MFC。这里主要是Visual C++下开发控制台程序。

C/C++程序的入口函数是main函数，这是C/C++程序的标准main入口函数。

main

Visual C++还提供了几个入口函数。比如wmain、_tmain，以及编写Win32和MFC应用程序的WinMain、wWinMain和_tWinMain。

wmain

这里的wmain和我们平常的main不同的就是前面带了一个w，这个w不是指的window或者窗口的意思，而是指的是wide宽字符的意思。wmain函数是main函数的宽字符版本。

关于main和wmain可参考这篇文章：

写道

https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-6.0/aa299386(v=vs.60)?redirectedfrom=MSDN

_tmain

这个其实就是一个宏定义，它最后还是会被替换为main或者wmain。使用_tmain做入口函数的时候要引入tchar.h头文件。

#include <tchar.h>

int _tmain()
{
  printf("this is _tmain.\n");
  return 0;
}

_tmain其实就只是一个在tchar.h中定义的宏，在宽字符环境下，_tmain被替换为wmain，否则还是会被替换为main，和我们平常写的main一样。

#ifdef  _UNICODE
...
#define _tmain      wmain
...
#else   /* ndef _UNICODE */
...
#define _tmain      main
...
#endif

在上面的例子中，如果在窄字符环境下，替换之后就是我们熟悉的int main() {...}。

#include <tchar.h>

int _tmain(int argc, TCHAR* argv[])
{
  printf("this is _tmain.\n");
  return 0;
}

在这个例子中，如果在窄字符环境下，替换之后就是我们熟悉的int main(int argc, char *argv[]) {...}。

#include <tchar.h>

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
  printf("this is _tmain.\n");
  return 0;
}

在这个例子中，如果在窄字符环境下，替换之后就是我们熟悉的int main(int argc, char *argv[], char *envp[]) {...}。

WinMain

INT WinMain(HINSTANCE hInstance, 
    HINSTANCE hPrevInstance,
    PSTR lpCmdLine, 
    INT nCmdShow);

wWinMain

int WINAPI wWinMain(HINSTANCE hInstance, 
    HINSTANCE hPrevInstance, 
    PWSTR pCmdLine, 
    int nCmdShow);

_tWinMain

#ifdef  _UNICODE
...
#define _tWinMain   wWinMain
...
#else   /* ndef _UNICODE */
...
#define _tWinMain   WinMain
...
#endif

编写静态链接库

在C: Linux C 编程中写过编写静态链接库:

写道

C: Linux C 编程 - 编写静态链接库
https://www.iteye.com/blog/lobin-2326336

通过comment pragma链入静态链接库

#pragma comment( comment-type [ , "comment-string" ] )

这种方式需要在代码中通过comment pragma链入静态链接库：

#pragma comment(lib, "qt.lib")

qt.h

#include <stddef.h>

#if ! defined(QT)
#define QT
struct qt
{
  size_t size;
  char data[];
};

struct qt* qt(int i);

int qt_get(struct qt* v);

int qt_destroy(struct qt* v);
#endif

qt.c

#include<stdlib.h>
#include<string.h>
#include"qt.h"

struct qt* qt(int i)
{
  size_t size = sizeof(i);
  struct qt* v = (struct qt*) malloc(sizeof(struct qt) + size);
  if (v != NULL)
  {
    v->size = size;
    memcpy(v->data, &i, sizeof(i));
  }
  return v;
}

int qt_get(struct qt* v)
{
  int *p = NULL;
  if (v == NULL)
  {
    return 0;
  }
  p = (int *) v->data;
  return *p;
}

int qt_destroy(struct qt* v)
{
  free(v);
  return 0;
}

编译

>"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\cl.exe" /GX /W3 /I "D:\usr\bin\Microsoft Visual Studio\VC98\Include" /c qt.c

生成静态库

>"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\lib.exe" /nologo qt.obj /out:./qt.lib

调用

static_test.c

#pragma comment(lib, "qt.lib")

#include <stdio.h>
#include "qt.h"

int main()
{
  int i = 1413;
  struct qt* v = qt(i);
  if (v == NULL)
  {
    return 1;
  }
  printf("qt: i=%d\n", qt_get(v));
  qt_destroy(v);
  return 0;
}

这里调用的时候，通过comment pragma链入静态链接库：

#pragma comment(lib, "qt.lib")

编译链接

>"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\cl.exe" /GX /W3 /I "D:\usr\bin\Microsoft Visual Studio\VC98\Include" static_test.c

运行

>.\static_test.exe

qt: i=1413

查看程序依赖的库

这个是查看程序依赖的动态链接库，这里是链接的静态库，静态库代码直接链入到程序中了，所以这里是查看不到依赖的静态库的。

>ldd static_test.exe

ntdll.dll => /cygdrive/c/WINDOWS/system32/ntdll.dll (0x7c92000

kernel32.dll => /cygdrive/c/WINDOWS/system32/kernel32.dll (0x7

c800000)

链接时直接指定要链入的静态链接库

编译

>"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\cl.exe" /GX /W3 /I "D:\usr\bin\Microsoft Visual Studio\VC98\Include" /c qt.c

生成静态库

>"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\lib.exe" /nologo qt.obj /out:./qt.lib

调用

static_test.c

#include <stdio.h>
#include "qt.h"

int main()
{
  int i = 1413;
  struct qt* v = qt(i);
  if (v == NULL)
  {
    return 1;
  }
  printf("qt: i=%d\n", qt_get(v));
  qt_destroy(v);
  return 0;
}

这里调用的时候，不通过comment pragma链入静态链接库

而是在链接的时候直接指定要链入的静态链接库

编译

>"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\cl.exe" /GX /W3 /I "D:\usr\bin\Microsoft Visual Studio\VC98\Include" /c static_test.c

链接

>"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\link.exe" /LIBPATH:"D:\usr\bin\Microsoft Visual Studio\VC98\Lib" static_test.obj ./qt.lib

运行

>.\static_test.exe

qt: i=1413

查看程序依赖的库

这个是查看程序依赖的动态链接库，这里是链接的静态库，静态库代码直接链入到程序中了，所以这里是查看不到依赖的静态库的。

>ldd static_test.exe

ntdll.dll => /cygdrive/c/WINDOWS/system32/ntdll.dll (0x7c92000

kernel32.dll => /cygdrive/c/WINDOWS/system32/kernel32.dll (0x7

c800000)

线程

线程ID

线程ID可以通过GetCurrentThreadId()获取。

线程句柄

创建线程时返回的一个线程句柄。用于指向内部创建的线程对象。

C Run-Time Libraries (CRT)

_beginthread和_beginthreadex

_beginthread

写道

uintptr_t _beginthread( // NATIVE CODE
void( __cdecl *start_address )( void * ),
unsigned stack_size,
void *arglist
);
uintptr_t _beginthread( // MANAGED CODE
void( __clrcall *start_address )( void * ),
unsigned stack_size,
void *arglist
);

写道

_CRTIMP unsigned long __cdecl _beginthread (void (__cdecl *) (void *),
unsigned, void *);

_beginthread返回的是新创建线程的句柄。

void start_address(void *arg)  
{
  char * name = (char *) arg;
  printf("thread %s\n", name);  
}
   
int main()  
{
  unsigned long th;  
  th = _beginthread(start_address, 0, "1");
  ExitThread(0);  
  return 0;  
}

"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\cl.exe" /GX /W3 /MT /I "D:\usr\bin\Microsoft Visual Studio\VC98\Include" /c /Fo./ beginthread_test.c

"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\link.exe" /LIBPATH:"D:\usr\bin\Microsoft Visual Studio\VC98\Lib" /OUT:./beginthread_test.exe ./beginthread_test.obj

获取线程返回退出状态

void start_address(void *args)  
{
  unsigned exit_code = (unsigned) args;
  printf("%d(%u)-%u thread exit(%u)\n", getpid(), GetCurrentProcessId(), GetCurrentThreadId(), exit_code);

  _endthreadex(exit_code);
}
   
int main()  
{
  HANDLE hThread;

  DWORD exit_code = 0;

  hThread = (HANDLE) _beginthread(start_address, 0, (void *) 100);

  WaitForSingleObject(hThread, INFINITE);

  GetExitCodeThread(hThread, &exit_code);
  printf("thread id: %u, exit(%d)\n", -1, exit_code);

  ExitThread(0);
  return 0;  
}

"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\cl.exe" /GX /W3 /MT /I "D:\usr\bin\Microsoft Visual Studio\VC98\Include" /c /Fo./ beginthread_test2.c

"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\link.exe" /LIBPATH:"D:\usr\bin\Microsoft Visual Studio\VC98\Lib" /OUT:./beginthread_test2.exe ./beginthread_test2.obj

_beginthreadex

写道

uintptr_t _beginthreadex( // NATIVE CODE
void *security,
unsigned stack_size,
unsigned ( __stdcall *start_address )( void * ),
void *arglist,
unsigned initflag,
unsigned *thrdaddr
);
uintptr_t _beginthreadex( // MANAGED CODE
void *security,
unsigned stack_size,
unsigned ( __clrcall *start_address )( void * ),
void *arglist,
unsigned initflag,
unsigned *thrdaddr
);

写道

_CRTIMP unsigned long __cdecl _beginthreadex(void *, unsigned,
unsigned (__stdcall *) (void *), void *, unsigned, unsigned *);

_beginthreadex与_beginthread不同的是，_beginthreadex多了几个参数：security，initflag以及thrdaddr。

initflag

用于指定新创建线程的初始状态。

如果指定为0，线程创建后将立即执行。

如果指定为CREATE_SUSPENDED，线程创建后不会立即执行，处于挂起状态。可以调用ResumeThread恢复执行。

如果指定为STACK_SIZE_PARAM_IS_A_RESERVATION，使用stack_size作为初始预留线程栈大小，如果没有指定为STACK_SIZE_PARAM_IS_A_RESERVATION，stack_size指定的是线程栈的commit大小。

thrdaddr
用于返回线程id。

该线程id可以通过GetCurrentThreadId()获取。

_beginthreadex返回的是新创建线程的句柄。

unsigned __stdcall start_address(void *arg)  
{  
  char * name = (char *) arg;
  printf("thread %s\n", name);
  return 0;
}  
   
int main()  
{
  unsigned long th;
  unsigned thread;  
  th = _beginthreadex(NULL, 0, start_address, "1", 0, &thread);

  ExitThread(0);
  return 0;  
}

"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\cl.exe" /GX /W3 /MT /I "D:\usr\bin\Microsoft Visual Studio\VC98\Include" /c /Fo./ beginthreadex_test.c

"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\link.exe" /LIBPATH:"D:\usr\bin\Microsoft Visual Studio\VC98\Lib" /OUT:./beginthreadex_test.exe ./beginthreadex_test.obj

获取线程返回退出状态

unsigned __stdcall start_address(void *args)  
{  
  unsigned exit_code = (unsigned) args;
  printf("%d(%u)-%u thread exit(%u)\n", getpid(), GetCurrentProcessId(), GetCurrentThreadId(), exit_code);
  return exit_code;
}  
   
int main()  
{
  HANDLE hThread;
  unsigned thread;

  DWORD exit_code = 0;

  hThread = (HANDLE) _beginthreadex(NULL, 0, start_address, (void *) 100, 0, &thread);

  WaitForSingleObject(hThread, INFINITE);

  GetExitCodeThread(hThread, &exit_code);
  printf("thread id: %u, exit(%d)\n", thread, exit_code);

  ExitThread(0);
  return 0;  
}

"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\cl.exe" /GX /W3 /MT /I "D:\usr\bin\Microsoft Visual Studio\VC98\Include" /c /Fo./ beginthreadex_test3.c

"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\link.exe" /LIBPATH:"D:\usr\bin\Microsoft Visual Studio\VC98\Lib" /OUT:./beginthreadex_test3.exe ./beginthreadex_test3.obj

C Run-Time Library _beginthread， _beginthreadex to create thread

#ifndef _MT
#error "Compiler linking options /MT not specific"
#endif
 
#include <stdio.h>
#include <windows.h>
#include <process.h>
 
void start_address(void *arg)
{
printf("_beginthread start_address\n");
}
 
unsigned __stdcall start_address_ex(void *arg)
{
printf("_beginthreadex start_address_ex\n");
return 0;
}
 
int main()
{
#ifdef _MT 
printf("MT defined\n");
#endif
 
unsigned long th;
printf("Thread _beginthread test\n");
th = _beginthread(start_address, 
0, 
NULL);
printf("_beginthread return %ld\n", th);
 
unsigned thread;
// CREATE_SUSPENDED 
th = _beginthreadex(NULL, 0, start_address_ex, NULL, 0, &thread);
ExitThread(0);
return 0;
}
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
DEBUG=../Debug
PATH_VS=D:\usr\bin\Microsoft Visual Studio\VC98
CL="$(PATH_VS)\Bin\cl.exe"
LINK="$(PATH_VS)\Bin\link.exe"
 
INCLUDE="D:\usr\bin\Microsoft Visual Studio\VC98\Include"
LIB="D:\usr\bin\Microsoft Visual Studio\VC98\Lib"
INCLUDE_LIB_LOG=D:\home\admin\workstation\c\liblog
LIB_LIB_LOG=D:\home\admin\workstation\c\liblog\Debug
 
 
 
liblog.lib: clean 
 
# using compiler linking options /MT, If compiles _beginthread edition of Thread
$(CL) /GX /W3 /MT /I $(INCLUDE) /c /Fo$(DEBUG)/ ThreadTest__beginthread.cpp
 
$(LINK) /LIBPATH:$(LIB) /OUT:$(DEBUG)/Thread_beginthreadTest.exe $(DEBUG)/*.obj
 
clean:
rm -Rf ./*.bak
rm -Rf ./*.o
rm -Rf ./*.obj
rm -Rf ./*.exe
rm -Rf ../Debug/*
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
运行结果：
 
MT defined
Thread _beginthread test
_beginthread return 2024
_beginthread start_address
_beginthreadex start_address_ex

自定义控制台窗口图标

#include <stdio.h>
#include <tchar.h>
#include <windows.h>

#include "resource.h"

typedef HWND (WINAPI * GETCONSOLEPROC)();

HWND GetConsole()
{
  HWND hRet(NULL);
  BOOL bLoad(FALSE);

  HMODULE hMod = GetModuleHandle(_T("kernel32.dll"));
  if(hMod == NULL)
  {
    hMod = LoadLibrary(_T("kernel32.dll"));    
    bLoad = TRUE;
  }
  if(hMod != NULL)
  {
	GETCONSOLEPROC pFun = (GETCONSOLEPROC) GetProcAddress(hMod, "GetConsoleWindow");
    if(pFun != NULL)
    {
      hRet = pFun();
    }
    if(bLoad)
    {
      FreeLibrary(hMod);
    }
  }
  return hRet;
}

int main(int argc, char* argv[])
{
  HWND hConsole = GetConsole();
  if(hConsole != NULL)
  {
    HICON hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1));
    SendMessage(hConsole, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
    SendMessage(hConsole, WM_SETICON, ICON_SMALL, (LPARAM)hIcon);
  }
  printf("hello c!\n");
  return 0;
}

resource.h

#define IDI_ICON1                       101

// Next default values for new objects
// 
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        102
#define _APS_NEXT_COMMAND_VALUE         40001
#define _APS_NEXT_CONTROL_VALUE         1000
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif

rs.rc

#include "resource.h"

#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS

/////////////////////////////////////////////////////////////////////////////
// Chinese (中国) resources

#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_CHS)
#ifdef _WIN32
LANGUAGE LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED
#pragma code_page(936)
#endif //_WIN32

#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//

1 TEXTINCLUDE DISCARDABLE 
BEGIN
    "resource.h\0"
END

2 TEXTINCLUDE DISCARDABLE 
BEGIN
    "#include ""afxres.h""\r\n"
    "\0"
END

3 TEXTINCLUDE DISCARDABLE 
BEGIN
    "\r\n"
    "\0"
END

#endif    // APSTUDIO_INVOKED


/////////////////////////////////////////////////////////////////////////////
//
// Icon
//

// Icon with lowest ID value placed first to ensure application icon
// remains consistent on all systems.
IDI_ICON1               ICON    DISCARDABLE     "icon.ico"
#endif    // Chinese (中国) resources
/////////////////////////////////////////////////////////////////////////////



#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//


/////////////////////////////////////////////////////////////////////////////
#endif    // not APSTUDIO_INVOKED

编译源程序

>cl /c console_test.cpp

编译资源

>"D:\usr\bin\Microsoft Visual Studio\Common\MSDev98\Bin\RC.EXE" /fo"rs.res" rs.rc

链接

"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\link.exe" /LIBPATH:"D:\usr\bin\Microsoft Visual Studio\VC98\Lib" /OUT:./console_test.exe ./console_test.obj rs.res user32.lib

中断

中断处理函数

C编写中断处理函数不是那么容易的。中断处理函数和普通的函数不一样，中断处理函数不像普通函数那样使用ret返回，它使用iret返回退出中断。此外，中断处理函数要求是可重入函数。现在很多编译器（包括C编译器）都不支持编写中断处理函数。C语言标准也没有对中断处理函数标准化。

一些C编译器通过扩展来提供中断处理函数，如TURBO C，GCC等。

TURBO C编写中断处理函数可参考下面的例子。

线程

C++：线程封装

/*
 * Thread that support cross platform and support global and local start routine, and support 
 * Windows api and C Run-Time Library(even extension) on windows. 
 * <p>
 * To implements a simple thread, only to overrides the run method.
 *
 * @author ada
 * @version 1.0
 * @since 1.0
 */
#include <windows.h>
#include "Runnable.hpp"
 
#if ! defined THREAD
#define THREAD
 
// GLOBAL_START_ROUTINE is a user defined macro, likes a switch, to determine whether to 
// select global thread start routine or not. GLOBAL_START_ROUTINE can be defined in program, 
// or using compiler preprocessor options(PREPROCESSOR) /D to define user defined macro 
// GLOBAL_START_ROUTINE to compiles global start routine edition of Thread
#if defined GLOBAL_START_ROUTINE 
 
#define _GLOBAL_START_ROUTINE
#pragma message ("GLOBAL_START_ROUTINE defined, using global thread start routine.")
 
// using compiler linking options /MT to compiles C Run-Time Library(_beginthread, _beginthreadex) 
// edition of Thread
#if defined(_MT) && (! defined(_MT_RT_EX))
#pragma message ("Using C Run-Time Library global thread start routine.")
//#error "C Run-Time Library global thread start routine not supported."
void execute(void *args);
 
#elif defined(_MT) && defined(_MT_RT_EX)
#pragma message ("Using C Run-Time Library extension global thread start routine.")
//#error "C Run-Time Library extension global thread start routine not supported."
unsigned __stdcall execute(void *arg);
 
#else 
DWORD execute(LPVOID args);
#endif
 
#else 
 
#pragma message ("GLOBAL_START_ROUTINE not defined, do not using global thread start routine.")
// If GLOBAL_START_ROUTINE not defined, for thread start routine function details, See Thread class 
// declaration when user defined macro defined
#endif
 
/**
 *
 *
 *
 */
class /*TK_API*/ Thread : public Runnable 
{
 
private:
 
DWORD threadID;
 
Runnable *target;
 
public:
 
Thread();
 
Thread(const Runnable *runnable);
 
#if ! defined _GLOBAL_START_ROUTINE
#if defined(_MT) && (! defined(_MT_RT_EX))
#pragma message ("Using C Run-Time Library global thread start routine.")
#error "C Run-Time Library global thread start routine not supported."
#elif defined(_MT) && defined(_MT_RT_EX)
#pragma message ("Using C Run-Time Library extension global thread start routine.")
#error "C Run-Time Library extension global thread start routine not supported."
#else 
static DWORD execute(LPVOID args);
#endif
#endif
 
void start();
 
virtual void run();
 
};
 
#endif
 
======================================================================
 
/*
 *
 *
 * @AUTHOR ADA
 * @VERSION 1.0
 * @SINCE 1.0
 */
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <windows.h>
#include <log.h>
#include "Thread.hpp"
 
//#define _MT
using namespace std;
 
#if ! defined _GLOBAL_START_ROUTINE 
DWORD Thread::execute(LPVOID args)
{
Thread* t = (Thread *) args;
    t->run();
return 1;
}
#else 
#if defined(_MT) && (! defined(_MT_RT_EX))
void execute(void *args)
{
Thread* t = (Thread *) args;
    t->run();
}
#elif defined(_MT) && defined(_MT_RT_EX)
unsigned __stdcall execute(void *arg)
{
Thread* t = (Thread *) args;
    t->run();
return 0;
}
#else
DWORD execute(LPVOID args) 
{
Thread* t = (Thread *) args;
    t->run();
return 1;
}
#endif
#endif
 
/**
 *
 *
 *
 */
Thread::Thread() 
{
    this->threadID = 0;
this->target = NULL;
}
 
Thread::Thread(const Runnable *runnable)
{
this->threadID = 0;
this->target = (Runnable *) runnable;
}
 
void Thread::start() 
{
#ifndef _GLOBAL_START_ROUTINE
LPTHREAD_START_ROUTINE startRoutine = (LPTHREAD_START_ROUTINE) Thread::execute;
printf("GLOBAL_START_ROUTINE not defined, do not using global thread start routine\n");
#else
LPTHREAD_START_ROUTINE startRoutine = (LPTHREAD_START_ROUTINE) execute;
printf("GLOBAL_START_ROUTINE defined, using global thread start routine\n");
#endif
::CreateThread(NULL, 0, startRoutine, (LPVOID) this, 0, &(this->threadID));
 
debug("Thread %d started", this->threadID);
}
 
void Thread::run() 
{
if (target != NULL) 
{
   target->run();
}
else 
{
debug("Thread::run()");
}
}
 
 
================================================================================
 
#ifndef _MT
#error "Compiler linking options /MT not specific"
#endif
 
#include <stdio.h>
#include <windows.h>
#include <process.h>
 
#include "../Thread.hpp"
#include "../LinkedLibrary.h"
 
void start_address(void *arg)
{
printf("_beginthread start_address\n");
}
 
unsigned __stdcall start_address_ex(void *arg)
{
printf("_beginthreadex start_address_ex\n");
return 0;
}
 
int main()
{
printf("Thread test\n");
 
#ifdef _MT 
printf("MT defined\n");
#endif
 
unsigned long th;
printf("Thread _beginthread test\n");
th = _beginthread(start_address, 
0, 
NULL);
printf("_beginthread return %ld\n", th);
 
unsigned thread;
// CREATE_SUSPENDED 
th = _beginthreadex(NULL, 0, start_address_ex, NULL, 0, &thread);
 
 
Thread *t = new Thread();
t->start();
 
ExitThread(0);
return 0;
}
 
===================================================================
 
DEBUG=../Debug
PATH_VS=D:\usr\bin\Microsoft Visual Studio\VC98
CL="$(PATH_VS)\Bin\cl.exe"
LINK="$(PATH_VS)\Bin\link.exe"
 
INCLUDE="D:\usr\bin\Microsoft Visual Studio\VC98\Include"
LIB="D:\usr\bin\Microsoft Visual Studio\VC98\Lib"
 
INCLUDE_LIB_LOG=D:\home\admin\workstation\c\liblog
LIB_LIB_LOG=D:\home\admin\workstation\c\liblog\Debug
 
INCLUDE_MYSQL=D:\usr\srv\mysql51\include
LIB_MYSQL=D:\usr\srv\mysql51\lib\debug
 
INCLUDE_LUA=D:\usr\bin\Lua\5.1\include
LIB_LUA=D:\usr\bin\Lua\5.1\lib
 
liblog.lib: clean 
 
# using compiler linking options /MT, If compiles _beginthread edition of Thread
$(CL) /GX /W3 /MT /DGLOBAL_START_ROUTINE /I $(INCLUDE) /I $(INCLUDE_LIB_LOG) /c /Fo$(DEBUG)/ ../Thread.cpp
$(CL) /GX /W3 /MT /DGLOBAL_START_ROUTINE /I $(INCLUDE) /c /Fo$(DEBUG)/ ThreadTest__beginthread.cpp
 
$(LINK) /LIBPATH:$(LIB) /LIBPATH:$(LIB_LIB_LOG) /LIBPATH:$(LIB_MYSQL) /LIBPATH:$(LIB_LUA) /OUT:$(DEBUG)/ThreadTest__beginthread.exe $(DEBUG)/*.obj
cp ../liblog.dll $(DEBUG)
clean:
rm -Rf ./*.bak
rm -Rf ./*.o
rm -Rf ./*.obj
rm -Rf ./*.exe
rm -Rf ../Debug/*

C++ Thread class

/*
 * Thread that support cross platform and support global and local start routine, and support 
 * Windows api and C Run-Time Library(even extension) on windows. 
 * <p>
 * To implements a simple thread, only to overrides the run method.
 *
 * @author ada
 * @version 1.0
 * @since 1.0
 */
#include <windows.h>
#if defined(_WIN32) && defined(_MT)
#include <process.h>
#endif
#include "Runnable.hpp"
 
#if ! defined THREAD
#define THREAD
 
// GLOBAL_START_ROUTINE is a user defined macro, likes a switch, to determine whether to 
// select global thread start routine or not. GLOBAL_START_ROUTINE can be defined in program, 
// or using compiler preprocessor options(PREPROCESSOR) /D to define user defined macro 
// GLOBAL_START_ROUTINE to compiles global start routine edition of Thread
#if defined GLOBAL_START_ROUTINE 
 
#define _GLOBAL_START_ROUTINE
#pragma message ("GLOBAL_START_ROUTINE defined, using global thread start routine.")
 
// windows
#ifdef _WIN32 
// using compiler linking options /MT to compiles C Run-Time Library(_beginthread, _beginthreadex) 
// edition of Thread
#if defined(_MT) && (! defined(_MT_RT_EX))
#pragma message ("Using C Run-Time Library global thread start routine.")
//#error "C Run-Time Library global thread start routine not supported."
void execute(void *args);
typedef void (* LP_CRT_THREAD_START_ROUTINE)(void *args);
 
#elif defined(_MT) && defined(_MT_RT_EX)
#pragma message ("Using C Run-Time Library extension global thread start routine.")
//#error "C Run-Time Library extension global thread start routine not supported."
unsigned __stdcall execute(void *args);
typedef unsigned (__stdcall * LP_CRT_EX_THREAD_START_ROUTINE)(void *args);
 
#else 
DWORD execute(LPVOID args);
#endif
 
// linux
#else
void* execute(void *args);
#endif
 
// User defined macro GLOBAL_START_ROUTINE is not specific
// Compiles global start routine edition of Thread using compiler preprocessor options(PREPROCESSOR) /D 
// to define user defined macro GLOBAL_START_ROUTINE
#else 
 
#pragma message ("GLOBAL_START_ROUTINE not defined, do not using global thread start routine.")
// If GLOBAL_START_ROUTINE not defined, for thread start routine function details, See Thread class 
// declaration when user defined macro defined
#endif
 
/**
 *
 *
 *
 */
class /*TK_API*/ Thread : public Runnable 
{
 
private:
 
#if defined(_WIN32) && defined(_MT)
#ifdef _MT_RT_EX
unsigned threadID;
#else
unsigned long threadID;
#endif
#else
DWORD threadID;
#endif
 
Runnable *target;
 
public:
 
Thread();
 
Thread(const Runnable *runnable);
 
#if ! defined _GLOBAL_START_ROUTINE
// windows
#ifdef _WIN32 
#if defined(_MT) && (! defined(_MT_RT_EX))
#pragma message ("Using C Run-Time Library global thread start routine.")
#error "C Run-Time Library global thread start routine not supported."
#elif defined(_MT) && defined(_MT_RT_EX)
#pragma message ("Using C Run-Time Library extension global thread start routine.")
#error "C Run-Time Library extension global thread start routine not supported."
#else 
static DWORD execute(LPVOID args);
#endif
// linux
#else
static void* execute(void *args);
#endif
#endif
 
void start();
 
virtual void run();
 
};
 
#endif
 
======================================================================
 
/*
 *
 *
 * @AUTHOR ADA
 * @VERSION 1.0
 * @SINCE 1.0
 */
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <windows.h>
#include <log.h>
#include "Thread.hpp"
 
//#define _MT
using namespace std;
 
#if ! defined _GLOBAL_START_ROUTINE 
DWORD Thread::execute(LPVOID args)
{
Thread* t = (Thread *) args;
    t->run();
return 1;
}
#else 
#if defined(_MT) && (! defined(_MT_RT_EX))
void execute(void *args)
{
debug("start routine defined(_MT) && (! defined(_MT_RT_EX))");
Thread* t = (Thread *) args;
    t->run();
}
#elif defined(_MT) && defined(_MT_RT_EX)
unsigned __stdcall execute(void *args)
{
debug("start routine defined(_MT) && defined(_MT_RT_EX)");
Thread* t = (Thread *) args;
    t->run();
return 0;
}
#else
DWORD execute(LPVOID args) 
{
Thread* t = (Thread *) args;
    t->run();
return 1;
}
#endif
#endif
 
/**
 *
 *
 *
 */
Thread::Thread() 
{
    this->threadID = 0;
this->target = NULL;
}
 
Thread::Thread(const Runnable *runnable)
{
this->threadID = 0;
this->target = (Runnable *) runnable;
}
 
void Thread::start() 
{
#if defined(_MT) && (! defined(_MT_RT_EX))
#ifndef _GLOBAL_START_ROUTINE
LP_CRT_THREAD_START_ROUTINE startRoutine = (LP_CRT_THREAD_START_ROUTINE) Thread::execute;
printf("GLOBAL_START_ROUTINE not defined, do not using global thread start routine\n");
#else
LP_CRT_THREAD_START_ROUTINE startRoutine = (LP_CRT_THREAD_START_ROUTINE) execute;
printf("GLOBAL_START_ROUTINE defined, using global thread start routine\n");
#endif
 
#elif defined(_MT) && defined(_MT_RT_EX)
#ifndef _GLOBAL_START_ROUTINE
LP_CRT_EX_THREAD_START_ROUTINE startRoutine = (LP_CRT_EX_THREAD_START_ROUTINE) Thread::execute;
printf("GLOBAL_START_ROUTINE not defined, do not using global thread start routine\n");
#else
LP_CRT_EX_THREAD_START_ROUTINE startRoutine = (LP_CRT_EX_THREAD_START_ROUTINE) execute;
printf("GLOBAL_START_ROUTINE defined, using global thread start routine\n");
#endif
 
#else
#ifndef _GLOBAL_START_ROUTINE
LPTHREAD_START_ROUTINE startRoutine = (LPTHREAD_START_ROUTINE) Thread::execute;
printf("GLOBAL_START_ROUTINE not defined, do not using global thread start routine\n");
#else
LPTHREAD_START_ROUTINE startRoutine = (LPTHREAD_START_ROUTINE) execute;
printf("GLOBAL_START_ROUTINE defined, using global thread start routine\n");
#endif
#endif
 
#if defined(_MT) && (! defined(_MT_RT_EX))
debug("begin thread through _beginthread()");
threadID = _beginthread(startRoutine, 
0, 
(void *) this);
#elif defined(_MT) && defined(_MT_RT_EX)
debug("begin thread through _beginthreadex()");
threadID =  _beginthreadex(NULL, 0, startRoutine, (void *) this, 0, &(this->threadID));
#else
::CreateThread(NULL, 0, startRoutine, (LPVOID) this, 0, &(this->threadID));
#endif
 
debug("Thread %d started", this->threadID);
}
 
void Thread::run() 
{
if (target != NULL) 
{
   target->run();
}
else 
{
debug("Thread::run()");
}
 
}

Windows下C/C++ 多线程同步（mutex）

#ifndef __LOCK
#define __LOCK
 
class Lock
{
public:
 
virtual void lock() = 0;
 
virtual void unlock() = 0;
};
 
#endif
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
#include <windows.h>
#include "Lock.hpp"
 
#ifndef _MUTEX_LOCK
#define _MUTEX_LOCK
 
class MutexLock : public Lock
{
 
private: 
 
HANDLE mutex;
 
public:
MutexLock();
 
MutexLock(const char* name);
 
void lock();
 
void lock(HANDLE mutex);
 
void unlock();
 
void unlock(HANDLE mutex);
 
HANDLE getMutex();
};
 
#endif
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
#include <stdlib.h>
#include <stdio.h>
#include <windows.h>
#include "log.h"
#include "MutexLock.hpp"
 
MutexLock::MutexLock()
{
this->mutex = CreateMutex(NULL, FALSE, NULL);
if (this->mutex == NULL) 
{
DWORD error = GetLastError();
warn("create mutex error %d", error);
}
debug("MutexLock()");
}
 
MutexLock::MutexLock(const char* name) 
{
this->mutex = CreateMutex(NULL, FALSE, name);
if (this->mutex == NULL) 
{
DWORD error = GetLastError();
warn("create mutex error %d", error);
}
else 
{
DWORD error = GetLastError();
if (error == ERROR_ALREADY_EXISTS) 
{
debug("mutex name %s already exists, use the existed mutex instead.", name);
}
}
}
 
void MutexLock::lock()
{
lock(this->mutex);
}
 
void MutexLock::lock(HANDLE mutex)
{
DWORD event = WaitForSingleObject(mutex, INFINITE);
if (event == WAIT_FAILED) 
{
DWORD error = GetLastError();
warn("wait error %d", error);
}
else if(event == WAIT_TIMEOUT) 
{
debug("wait time out");
}
else if(event == WAIT_ABANDONED) 
{
debug("wait abandoned");
}
}
 
void MutexLock::unlock()
{
this->unlock(this->mutex);
}
 
void MutexLock::unlock(HANDLE mutex) 
{
BOOL isr = ReleaseMutex(this->mutex);
if (! isr) 
{
DWORD error = GetLastError();
warn("release mutex error %d", error);
}
}
 
HANDLE MutexLock::getMutex()
{
return this->mutex;
}
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
#define _WIN32_WINNT 0x0400
#include <stdio.h>
#include <windows.h>
#include "../MutexLock.hpp"
#include "../Thread.hpp"
 
 
#ifndef MESSAGE_DESTINATION
#define MESSAGE_DESTINATION
 
class MessageDestination 
{
private: 
MutexLock lock;
 
int i;
 
public:
MessageDestination()
{
i = 0;
}
 
void add()
{
lock.lock();
i++;
printf("[Producer] message %d\n", this->i);
lock.unlock();
 
}
 
void reduce()
{
lock.lock();
i--;
printf("[Consumer] message %d\n", i);
lock.unlock();
}
};
#endif
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
#include <stdio.h>
#include "../MutexLock.hpp"
#include "../Thread.hpp"
#include "MessageDestination.hpp"
 
class MessageConsumer : public Thread 
{
private:
MessageDestination *destination;
 
 
public: 
MessageConsumer()
{
this->destination = NULL;
}
 
void registerConsumer(MessageDestination *destination) 
{
this->destination = destination;
}
 
 
void run() 
{
while (1)
{
if (destination != NULL) 
{
this->destination->reduce();
}
//Sleep(500);
}
}
};
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
#include <stdio.h>
#include "../MutexLock.hpp"
#include "../Thread.hpp"
#include "MessageDestination.hpp"
 
class MessageProducer : public Thread 
{
private:
MessageDestination *destination;
 
public: 
MessageProducer()
{
this->destination = NULL;
}
 
void registerProducer(MessageDestination *destination) 
{
this->destination = destination;
}
 
void run()
{
while (1) 
{
if (destination != NULL) 
{
destination->add();
}
//Sleep(5000);
}
}
};
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
#include "MessageDestination.hpp"
#include "MessageProducer.hpp"
#include "MessageConsumer.hpp"
 
void main()
{
///*
MessageDestination *destination = new MessageDestination();
 
MessageProducer *producer = new MessageProducer();
producer->registerProducer(destination);
producer->start();
 
MessageConsumer *consumer = new MessageConsumer();
consumer->registerConsumer(destination);
consumer->start();
 
 
ExitThread(0);
 
}

Windows下C/C++ 多线程同步（event）

#ifndef __LOCK
#define __LOCK
 
class Lock
{
public:
 
virtual void lock() = 0;
 
virtual void unlock() = 0;
};
 
#endif
 
===========================================================
 
#include <windows.h>
#include "Lock.hpp"
 
#ifndef _EVENT_LOCK
#define _EVENT_LOCK
 
class EventLock : public Lock
{
 
private: 
 
HANDLE event;
 
public:
EventLock();
 
EventLock(const char* name);
 
virtual void lock();
 
void lock(HANDLE event);
 
virtual void unlock();
 
void unlock(HANDLE event);
 
HANDLE getEvent();
};
 
#endif
 
 
============================================================
 
 
 
#include <stdlib.h>
#include <stdio.h>
#include <windows.h>
#include "log.h"
#include "EventLock.hpp"
 
EventLock::EventLock()
{
this->event = CreateEvent(NULL, FALSE, TRUE, NULL);
if (this->event == NULL) 
{
DWORD error = GetLastError();
warn("create event error %d", error);
}
debug("EventLock()");
}
 
EventLock::EventLock(const char* name) 
{
this->event = CreateEvent(NULL, FALSE, FALSE, name);
if (this->event == NULL) 
{
DWORD error = GetLastError();
warn("create event error %d", error);
}
else 
{
DWORD error = GetLastError();
if (error == ERROR_ALREADY_EXISTS) 
{
debug("event name %s already exists, use the existed event instead.", name);
}
}
}
 
void EventLock::lock()
{
lock(this->event);
}
 
void EventLock::lock(HANDLE event)
{
DWORD e = WaitForSingleObject(event, INFINITE);
if (e == WAIT_FAILED) 
{
DWORD error = GetLastError();
warn("wait error %d", error);
}
else if(e == WAIT_TIMEOUT) 
{
debug("wait time out");
}
else if(e == WAIT_ABANDONED) 
{
debug("wait abandoned");
}
}
 
void EventLock::unlock()
{
this->unlock(this->event);
}
 
void EventLock::unlock(HANDLE event) 
{
BOOL isr = SetEvent(this->event);
if (! isr) 
{
DWORD error = GetLastError();
warn("release event error %d", error);
}
}
 
HANDLE EventLock::getEvent()
{
return this->event;
}
 
 
 
================================================================
 
#define _WIN32_WINNT 0x0400
#include <stdio.h>
#include <windows.h>
#include "../Lock.hpp"
#include "../EventLock.hpp"
#include "../Thread.hpp"
 
 
#ifndef TEST_EVENT_LOCK_MESSAGE_DESTINATION
#define TEST_EVENT_LOCK_MESSAGE_DESTINATION
 
class TestEventLockMessageDestination 
{
private: 
Lock *lock;
//HANDLE hEvent;
int i;
 
public:
TestEventLockMessageDestination()
{
lock = new EventLock();
//hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
i = 0;
}
 
void add()
{
lock->lock();
i++;
printf("[Producer] message %d\n", this->i);
/*
if (i > 0) 
{
SetEvent(hEvent);
}
*/
lock->unlock();
 
}
 
void reduce()
{
lock->lock();
/*
if (i <= 0) 
{
ResetEvent(hEvent);
WaitForSingleObject(hEvent, INFINITE);
}
*/
 
i--;
printf("[Consumer] message %d\n", i);
 
lock->unlock();
}
};
#endif
 
==============================================================
 
#include <stdio.h>
#include "../Thread.hpp"
#include "TestEventLockMessageDestination.hpp"
 
#ifndef TEST_EVENT_LOCK_MESSAGE_PRODUCER
#define TEST_EVENT_LOCK_MESSAGE_PRODUCER
 
class TestEventLockMessageProducer : public Thread 
{
private:
TestEventLockMessageDestination *destination;
 
public: 
TestEventLockMessageProducer()
{
this->destination = NULL;
}
 
void registerProducer(TestEventLockMessageDestination *destination) 
{
this->destination = destination;
}
 
void run()
{
while (1) 
{
if (destination != NULL) 
{
destination->add();
}
Sleep(5000);
}
}
};
#endif
 
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
 
#include <stdio.h>
#include "../Thread.hpp"
#include "TestEventLockMessageDestination.hpp"
 
#ifndef TEST_EVENT_LOCK_MESSAGE_CONSUMER
#define TEST_EVENT_LOCK_MESSAGE_CONSUMER
 
class TestEventLockMessageConsumer : public Thread 
{
private:
TestEventLockMessageDestination *destination;
 
 
public: 
TestEventLockMessageConsumer()
{
this->destination = NULL;
}
 
void registerConsumer(TestEventLockMessageDestination *destination) 
{
this->destination = destination;
}
 
 
void run() 
{
while (1)
{
if (destination != NULL) 
{
this->destination->reduce();
}
Sleep(500);
}
}
};
#endif
 
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
 
#include "TestEventLockMessageDestination.hpp"
#include "TestEventLockMessageProducer.hpp"
#include "TestEventLockMessageConsumer.hpp"
 
void main()
{
///*
TestEventLockMessageDestination *destination = new TestEventLockMessageDestination();
 
TestEventLockMessageProducer *producer = new TestEventLockMessageProducer();
producer->registerProducer(destination);
producer->start();
 
TestEventLockMessageConsumer *consumer = new TestEventLockMessageConsumer();
consumer->registerConsumer(destination);
consumer->start();
 
/*
while(1)
{
Sleep(2000);
}
*/
ExitThread(0);
 
 
/*
DWORD threadID;
CreateThread(NULL, 0, Callback1, (LPVOID) NULL, 0, &threadID);
printf("Thread %ld started...\n", threadID);
 
CreateThread(NULL, 0, Callback2, (LPVOID) NULL, 0, &threadID);
printf("Thread %ld started...\n", threadID);
 
ExitThread(0);
*/
}

Windows下C/C++ 多线程同步

#include "Lock.hpp"
#include "EventLock.hpp"
 
#ifndef __SYNC
#define __SYNC
class Sync 
{
private:
 
protected:
 
EventLock *lock;
 
EventLock *block;
 
public:
 
Sync();
 
void wait();
 
void notify();
 
};
#endif
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
#include "EventLock.hpp"
#include "Sync.hpp"
 
Sync::Sync()
{
lock = new EventLock();
block = new EventLock();
}
 
void Sync::wait()
{
block->setState(EventLock::NON_SIGNALED);
lock->unlock();
block->lock();
lock->lock();
}
 
void Sync::notify()
{
block->setState(EventLock::SIGNALED);
}
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
#include <windows.h>
#include "Lock.hpp"
 
#ifndef _EVENT_LOCK
#define _EVENT_LOCK
 
class EventLock : public Lock
{
 
private: 
 
HANDLE event;
 
public:
const static int SIGNALED;
 
const static int NON_SIGNALED;
 
EventLock();
 
EventLock(const char* name);
 
virtual void lock();
 
void lock(HANDLE event);
 
virtual void unlock();
 
void unlock(HANDLE event);
 
void setState(int state);
 
HANDLE getEvent();
};
 
#endif
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
#include <stdlib.h>
#include <stdio.h>
#include <windows.h>
#include "log.h"
#include "EventLock.hpp"
 
const int EventLock::SIGNALED = 1;
 
const int EventLock::NON_SIGNALED = 0;
 
EventLock::EventLock()
{
this->event = CreateEvent(NULL, FALSE, TRUE, NULL);
if (this->event == NULL) 
{
DWORD error = GetLastError();
warn("create event error %d", error);
}
debug("EventLock()");
}
 
EventLock::EventLock(const char* name) 
{
this->event = CreateEvent(NULL, FALSE, FALSE, name);
if (this->event == NULL) 
{
DWORD error = GetLastError();
warn("create event error %d", error);
}
else 
{
DWORD error = GetLastError();
if (error == ERROR_ALREADY_EXISTS) 
{
debug("event name %s already exists, use the existed event instead.", name);
}
}
}
 
void EventLock::lock()
{
lock(this->event);
}
 
void EventLock::lock(HANDLE event)
{
DWORD e = WaitForSingleObject(event, INFINITE);
if (e == WAIT_FAILED) 
{
DWORD error = GetLastError();
warn("wait error %d", error);
}
else if(e == WAIT_TIMEOUT) 
{
debug("wait time out");
}
else if(e == WAIT_ABANDONED) 
{
debug("wait abandoned");
}
}
 
void EventLock::unlock()
{
this->unlock(this->event);
}
 
void EventLock::unlock(HANDLE event) 
{
BOOL isr = SetEvent(this->event);
if (! isr) 
{
DWORD error = GetLastError();
warn("release event error %d", error);
}
}
 
void EventLock::setState(int state)
{
if (state == EventLock::SIGNALED) 
{
int error = SetEvent(this->event);
if (! error) 
{
DWORD e = GetLastError();
warn("error to set event object to signaled state");
}
}
else if(state == EventLock::NON_SIGNALED) 
{
int error = ResetEvent(this->event);
if (! error) 
{
DWORD e = GetLastError();
warn("error to set event object to nonsignaled state");
}
}
}
 
HANDLE EventLock::getEvent()
{
return this->event;
}
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
#define _WIN32_WINNT 0x0400
#include <stdio.h>
#include <windows.h>
#include "../Sync.hpp"
 
 
#ifndef TEST_EVENT_LOCK_MESSAGE_DESTINATION
#define TEST_EVENT_LOCK_MESSAGE_DESTINATION
 
class TestEventLockMessageDestination : public Sync
{
private: 
 
int i;
 
public:
TestEventLockMessageDestination()
{
i = 0;
}
 
void add()
{
lock->lock();
i++;
printf("[Producer] message %d\n", this->i);
 
if (i > 0) 
{
this->notify();
}
 
lock->unlock();
}
 
void reduce()
{
lock->lock();
if (i <= 0) 
{
this->wait();
}
 
i--;
printf("[Consumer] message %d\n", i);
 
lock->unlock();
}
};
#endif
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
#include <stdio.h>
#include "../Thread.hpp"
#include "TestEventLockMessageDestination.hpp"
 
#ifndef TEST_EVENT_LOCK_MESSAGE_CONSUMER
#define TEST_EVENT_LOCK_MESSAGE_CONSUMER
 
class TestEventLockMessageConsumer : public Thread 
{
private:
TestEventLockMessageDestination *destination;
 
 
public: 
TestEventLockMessageConsumer()
{
this->destination = NULL;
}
 
void registerConsumer(TestEventLockMessageDestination *destination) 
{
this->destination = destination;
}
 
 
void run() 
{
while (1)
{
if (destination != NULL) 
{
this->destination->reduce();
}
//Sleep(500);
}
}
};
#endif
 
===================================================
 
#include <stdio.h>
#include "../Thread.hpp"
#include "TestEventLockMessageDestination.hpp"
 
#ifndef TEST_EVENT_LOCK_MESSAGE_PRODUCER
#define TEST_EVENT_LOCK_MESSAGE_PRODUCER
 
class TestEventLockMessageProducer : public Thread 
{
private:
TestEventLockMessageDestination *destination;
 
public: 
TestEventLockMessageProducer()
{
this->destination = NULL;
}
 
void registerProducer(TestEventLockMessageDestination *destination) 
{
this->destination = destination;
}
 
void run()
{
while (1) 
{
if (destination != NULL) 
{
destination->add();
}
//Sleep(5000);
}
}
};
#endif
 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
 
#include "TestEventLockMessageDestination.hpp"
#include "TestEventLockMessageProducer.hpp"
#include "TestEventLockMessageConsumer.hpp"
 
void main()
{
///*
TestEventLockMessageDestination *destination = new TestEventLockMessageDestination();
 
TestEventLockMessageProducer *producer = new TestEventLockMessageProducer();
producer->registerProducer(destination);
producer->start();
 
TestEventLockMessageConsumer *consumer = new TestEventLockMessageConsumer();
consumer->registerConsumer(destination);
consumer->start();
 
ExitThread(0);
 
}

Windows下网络编程Socket定义：WINSOCK2.H头文件SOCKET

通信_网络编程_WINDOWS下网络编程_SOCKET编程_VC中WINSOCK2.H头文件SOCKET.doc

通信网络编程 WINDOWS SOCKET 编程 VC WINSOCK2.H 头文件

Socket ，形象点可以把它理解为插槽，就像电源插座上面的插孔（不过电源插座上面的插孔有一孔的，还有两孔的，甚至还有三孔的，不知道还有没有四孔的，到目前为止我还没有看过有这么多孔的插座）。电器设备通过一条电源线，一端通过插头插入到能够输送电源的另一端的插座接入另一端，自己的一端也通过插头插入到自己的一个插孔上，将自己和能够输送电源的另一端建立一条物理连接。通过这样的一条物理连接，输送电源的另一端便可以将电源源源不断的输送过来，为电器设备提供电源，电器设备才可以借电力运转。

Socket 就类似这种情况，应用程序之间需要通信，就需要建立连接（这里的连接不是逻辑上的连接，而是物理上的连接，无线在这里也暂且把它归为是物理上的连接，只是连接的媒介不同而已）。现在假设连接的线有了，两端的节点也有了，并且连接的线两端也都套了一个能插入的插头，要实现通信，通信的应用程序还需要分别提供一个插槽以便将两头的插头都插入到插槽，这就是 SOCKET ！

以上只是举了些例子以便更形象的理解 Socket ，它只是逻辑上的概念， Sockets 也有专门的协议规范来标准化。在 rfc1928.txt 中，根据 OSI 模型， SOCKET 在概念上是一种位于应用层与传输层之间的中间层的网络传输协议。在实际实现上，例如在不同平台上的 Socket 的实现也有些差别。

在 WINDOWS 平台上， Socket 实现是在动态链接库 ws2_32.dll 中， VC 中的头文件 WINSOCK2.H 及 WINSOCK.H 有定义。

查看头文件定义，在 WINSOCK2.H 头文件中， SOCKET 由一个简单的类型定义将 SOCKET 定义为一个 u_int 类型，而 u_int 类型其实就是一个 unsigned int 类型：

* The new type to be used in all

* instances which refer to sockets.

typedef u_int SOCKET;

typedef unsigned int u_int;

创建 SOCKET

#if INCL_WINSOCK_API_PROTOTYPES

WINSOCK_API_LINKAGE

SOCKET

WSAAPI

socket(

int af,

int type,

int protocol

);

#endif // INCL_WINSOCK_API_PROTOTYPES

INCL_WINSOCK_API_PROTOTYPES 定义

#ifndef INCL_WINSOCK_API_PROTOTYPES

#define INCL_WINSOCK_API_PROTOTYPES 1

#endif

#ifndef INCL_WINSOCK_API_TYPEDEFS

#define INCL_WINSOCK_API_TYPEDEFS 0

#endif

WINSOCK_API_LINKAGE 定义

#ifndef WINSOCK_API_LINKAGE

#ifdef DECLSPEC_IMPORT

#define WINSOCK_API_LINKAGE DECLSPEC_IMPORT

#else

#define WINSOCK_API_LINKAGE

#endif

DECLSPEC_IMPORT 定义（在 WINNT.H 头文件中）

#if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC) || defined(_M_IA64)) && !defined(MIDL_PASS)

#define DECLSPEC_IMPORT __declspec(dllimport)

#else

#define DECLSPEC_IMPORT

#endif

WSAAPI 定义

#ifdef WIN32

#define WSAAPI FAR PASCAL

。。。

#else /* WIN16 */

#define WSAAPI FAR PASCAL

。。。

#endif /* WIN32 */

创建 SOCKET 函数 socket 返回创建的 SOCKET ，类型如上定义。此函数传入三个参数：

int af,

int type,

int protocol

第一个参数 af 传入的是地址家族（ address family ） , 也就是地址簇或者协议簇。

该参数在不同的系统下参数不一定相同，另外注意不同的版本可以使用的参数也不相同，可以参考相关文档。这里列出了所有要求的参数可用值。

参数 a. 地址族（与 TCP/IP 协议下的协议族等价）可以使用的参数如下

#define AF_UNIX 1 /* local to host (pipes, portals) */

#define AF_INET 2 /* internetwork: UDP, TCP, etc. */

#define AF_IMPLINK 3 /* arpanet imp addresses */

#define AF_PUP 4 /* pup protocols: e.g. BSP */

#define AF_CHAOS 5 /* mit CHAOS protocols */

#define AF_NS 6 /* XEROX NS protocols */

#define AF_IPX AF_NS /* IPX protocols: IPX, SPX, etc. */

#define AF_ISO 7 /* ISO protocols */

#define AF_OSI AF_ISO /* OSI is ISO */

#define AF_ECMA 8 /* european computer manufacturers */

#define AF_DATAKIT 9 /* datakit protocols */

#define AF_CCITT 10 /* CCITT protocols, X.25 etc */

#define AF_SNA 11 /* IBM SNA */

#define AF_DECnet 12 /* DECnet */

#define AF_DLI 13 /* Direct data link interface */

#define AF_LAT 14 /* LAT */

#define AF_HYLINK 15 /* NSC Hyperchannel */

#define AF_APPLETALK 16 /* AppleTalk */

#define AF_NETBIOS 17 /* NetBios-style addresses */

#define AF_VOICEVIEW 18 /* VoiceView */

#define AF_FIREFOX 19 /* Protocols from Firefox */

#define AF_UNKNOWN1 20 /* Somebody is using this! */

#define AF_BAN 21 /* Banyan */

#define AF_ATM 22 /* Native ATM Services */

#define AF_INET6 23 /* Internetwork Version 6 */

#define AF_CLUSTER 24 /* Microsoft Wolfpack */

#define AF_12844 25 /* IEEE 1284.4 WG AF */

#define AF_MAX 26

AF_UNIX // 表示 Unix 内部协议

AF_NS // 表示使用的是 Xerox NS 协议族

AF_IMPLINK// 表示 IMP 连接层

另外 AF_LOCAL 是用于 Unix/Linux 系统中本机进程间通信

第二个参数传入的是 SOCKET 类型，可传入的 SOCKET 类型如下：

参数 b.Socket 类型

可以取如下的一些值：

SOCK_STREAM 流套接字

SOCK_DGRAM 数据报套接字

SOCK_RAW 未加工套接字（可以用它来接收原始的数据包，即不经过传输层的，常用来抓包）

SOCK_SEQPACKET 顺序包套接字

#define SOCK_STREAM 1 /* stream socket */

#define SOCK_DGRAM 2 /* datagram socket */

#define SOCK_RAW 3 /* raw-protocol interface */

#define SOCK_RDM 4 /* reliably-delivered message */

#define SOCK_SEQPACKET 5 /* sequenced packet stream */

第三个参数传入的是协议类型，可传入的协议类型如下：

参数 c.Socket 使用的协议类型

通常将此设为 0 即 IPPROTO_IP ，是因为协议类型可以根据 Socket 的类型来确定，比如 Sock_STREAM 就是使用 TCP 协议，而 SOCK_DGRAM 就是使用 UDP 协议。

其他的类型还有 :

#define IPPROTO_ICMP 1 /* control message protocol */

#define IPPROTO_IGMP 2 /* internet group management protocol */

#define IPPROTO_GGP 3 /* gateway^2 (deprecated) */

#define IPPROTO_TCP 6 /* tcp */

#define IPPROTO_PUP 12 /* pup */

#define IPPROTO_UDP 17 /* user datagram protocol */

#define IPPROTO_IDP 22 /* xns idp */

#define IPPROTO_ND 77 /* UNOFFICIAL net disk proto */

#define IPPROTO_RAW 255 /* raw IP packet */

#define IPPROTO_MAX 256

网络编程－SOCKET－创建SOCKET－WINDOWS下socket函数声明问题

今天翻了下VC下SOCKET头文件WINSOCK2.H，又看了下socket函数的声明：

#if INCL_WINSOCK_API_PROTOTYPES
WINSOCK_API_LINKAGE
SOCKET
WSAAPI
socket(
    int af,
    int type,
    int protocol
    );
#endif // INCL_WINSOCK_API_PROTOTYPES

注意到#if INCL_WINSOCK_API_PROTOTYPES这个条件编译，通常我们是通过#if， #ifdef或者#ifndef来判断选择哪一部分来编译以及在#include时解决因为重复包含的问题。

但这里的#if INCL_WINSOCK_API_PROTOTYPES这个条件编译是啥意思？在WINSOCK2.H文件靠近开头的位置有有如下定义：

#ifndef INCL_WINSOCK_API_PROTOTYPES
#define INCL_WINSOCK_API_PROTOTYPES 1
#endif

也就是INCL_WINSOCK_API_PROTOTYPES始终被替换为1，那么既然为1，干嘛还需要这样一个条件？

Windows CryptoAPI

// win32-test.cpp : 定义控制台应用程序的入口点。
// 
// Defines the entry point for the console 
// application.

#include "stdafx.h"


#include <tchar.h>
#include <stdio.h>
#include <windows.h>
#include <wincrypt.h>
#include <conio.h>
#include <atlenc.h>

#include "encrypt.h"

// Link with the Advapi32.lib file.
#pragma comment (lib, "advapi32")



typedef struct {
    BYTE * keyData;
    int keyDataLen;
} B_RSAW;

typedef struct 
{
    char *keyData;
    int keDataLen;
} RSAW;

B_RSAW* RSA_key_w() 
{
    HCRYPTPROV hCryptProv = NULL; // handle to a cryptographic service provider (CSP)
    //---------------------------------------------------------------
    // Get the handle to the default provider. 
    // #param pszProvider  Cryptographic Provider Names
    //     MS_ENHANCED_PROV  "Microsoft Enhanced Cryptographic Provider v1.0"
    CryptAcquireContext(&hCryptProv, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
    if(CryptAcquireContext(
        &hCryptProv, 
        NULL, 
        MS_ENHANCED_PROV, // "Microsoft Enhanced Cryptographic Provider v1.0"
        PROV_RSA_FULL, 
        CRYPT_NEWKEYSET))
    {
        _tprintf(
            TEXT("A cryptographic provider has been acquired. \n"));
    }
    else
    {
        return NULL;
    }

    HCRYPTKEY hKey;// handle of the key
    if(CryptGenKey(
          hCryptProv, 
          AT_KEYEXCHANGE, 
          CRYPT_EXPORTABLE, 
          &hKey))
    {
         printf("A session key has been created.\n");
    } 
    else
    {
          printf("Error during CryptGenKey.\n"); 
          exit(1);
    }

    DWORD dwTempPriLen;
    int r = CryptExportKey(hKey, NULL, PRIVATEKEYBLOB, NULL, NULL, &dwTempPriLen);


    BYTE *pbTempPriData = (BYTE *)malloc(dwTempPriLen+1);
    r = CryptExportKey(hKey, NULL, PRIVATEKEYBLOB, NULL, pbTempPriData, &dwTempPriLen);

    //-------------------------------------------------------------------
    //  The key created can be exported into a key BLOB that can be
    //  written to a file.
    //  ...
    //  When you have finished using the key, free the resource.
    if (!CryptDestroyKey(hKey))
    {
          printf("Error during CryptDestroyKey.\n"); 
          exit(1);
    }
    if (! CryptReleaseContext(hCryptProv, 0)) 
    {
        printf("Error during CryptReleaseContext.\n"); 
          exit(1);
    }
    B_RSAW *rsa = (B_RSAW *) malloc(sizeof(B_RSAW));
    rsa->keyData = pbTempPriData;
    rsa->keyDataLen = dwTempPriLen;
    return rsa;
}

void RSA_key_write_RSAPrivateKey_W(const char* fn, B_RSAW* rsa) 
{
    FILE *fp = NULL;
    fp = fopen(fn, "wb");
    if (fp == NULL) {
        fprintf(stderr,"%s open error", fn);
    }
    printf("file %s opened...\n", fn);
    fwrite(rsa->keyData, 1, rsa->keyDataLen+1, fp);
    fclose(fp);
}

RSAW* RSA_key_base64_w(B_RSAW *rsa) 
{
    //B_RSAW *rsa = RSA_key_w();
    int len = Base64EncodeGetRequiredLength(rsa->keyDataLen, ATL_BASE64_FLAG_NONE);
    LPSTR szDest = (LPSTR) malloc(len + 1);
    memset(szDest, 0, len + 1);
    
    Base64Encode(rsa->keyData, rsa->keyDataLen, szDest, &len, ATL_BASE64_FLAG_NONE );

    
    
    RSAW *_rsa = (RSAW *) malloc(sizeof(RSAW));
    _rsa->keyData = szDest;
    _rsa->keDataLen = len + 1;
    return _rsa;
}

void RSA_key_write_RSAPrivateKey_base64_W(const char* fn, RSAW* rsa)
{
    FILE *fp2 = NULL;

    fp2 = fopen(fn, "wb");
    if (fp2 == NULL) {
        fprintf(stderr,"%s open error", fn);
        return;
    }
    //fwrite(rsa->keyData, 1, rsa->keyDataLen+1, fp);
    fprintf(fp2, "%s", rsa->keyData);
    //fclose(fp);
    fclose(fp2);
}


int _tmain(int argc, _TCHAR* argv[])
{
    /*
    if(argc < 3)
    {
        _tprintf(TEXT("Usage: <example.exe> <source file> ")
            TEXT("<destination file> | <password>\n"));
        _tprintf(TEXT("<password> is optional.\n"));
        _tprintf(TEXT("Press any key to exit."));
        _gettch();
        return 1;
    }
    */

    B_RSAW *rsa = RSA_key_w();

    char *fn = "D:\\home\\workspace1\\tst_edit\\MFCActiveXControl1\\win32-test\\test-g-win.key";
    RSA_key_write_RSAPrivateKey_W(fn, rsa);

    RSAW *_rsa = RSA_key_base64_w(rsa);
    char *fn2 = "D:\\home\\workspace1\\tst_edit\\MFCActiveXControl1\\win32-test\\test-g-2-win.key";
    RSA_key_write_RSAPrivateKey_base64_W(fn2, _rsa);

    /*
    LPTSTR pszSource = NULL; 
    LPTSTR pszDestination = NULL; 
    LPTSTR pszPassword = NULL;

    pszSource = L"D:\\home\\workspace1\\tst_edit\\MFCActiveXControl1\\win32-test\\plain-text.txt";
    pszDestination = L"D:\\home\\workspace1\\tst_edit\\MFCActiveXControl1\\win32-test\\encrypt-text.txt";
    pszPassword = L"yihaodian";

    //---------------------------------------------------------------
    // Call EncryptFile to do the actual encryption.
    if(MyEncryptFile(pszSource, pszDestination, pszPassword))
    {
        _tprintf(
            TEXT("Encryption of the file %s was successful. \n"), 
            pszSource);
        _tprintf(
            TEXT("The encrypted data is in file %s.\n"), 
            pszDestination);
    }
    else
    {
        MyHandleError(
            TEXT("Error encrypting file!\n"), 
            GetLastError()); 
    }
    */
    return 0;
}

有关 SOCKET 资料可参考：

维基百科 http://zh.wikipedia.org/wiki/SOCKS

IETF RFC 1928, rfc1928.txt, SOCKS Protocol Version 5

IETF RFC 1929, rfc1929.txt, Username/Password Authentication for SOCKS V5

各平台（ Linux 、 Unix 、 Windows 等）对 SOCKET 的实现

互联网传输协议的性能优化： http://shop.zte.com.cn/main/include/showemagazinearticle.jsp?articleId=369&catalogId=12165

VC下相关工具

lib

>LIB.EXE /LIST liblog_static.lib

Microsoft (R) Library Manager Version 6.00.8168

.\Debug\SocketAppender.obj

.\Debug\LoggerWrapper.obj

.\Debug\log.obj

.\Debug\GenericAppender.obj

.\Debug\FileAppender.obj

.\Debug\AsynchronizedAppender.obj

.\Debug\Appender.obj

.\Debug\StandardAppender.obj

Makefile

Windows Make file(VC, NMAKE)

>NMAKE /f "nmake_test.mak" CFG="nmake_test - Win32 Debug" /y /d

@echo "$(OS)"

!IF "$(OS)" == "Windows_NT"

NULL=

!ELSE

NULL=nul

!ENDIF

DEBUG=../Debug

PATH_VS=D:\usr\bin\Microsoft Visual Studio\VC98

CL="$(PATH_VS)\Bin\cl.exe"

LINK="$(PATH_VS)\Bin\link.exe"

INCLUDE="D:\usr\bin\Microsoft Visual Studio\VC98\Include"

LIB="D:\usr\bin\Microsoft Visual Studio\VC98\Lib"

INCLUDE_LIB_LOG=D:\home\admin\workstation\c\liblog

LIB_LIB_LOG=D:\home\admin\workstation\c\liblog\Debug

INCLUDE_MYSQL=D:\usr\srv\mysql51\include

LIB_MYSQL=D:\usr\srv\mysql51\lib\debug

liblog.lib: clean

$(CL) /GX /W3 /I $(INCLUDE) /c /Fo$(DEBUG)/ ../SQLException.cpp

$(CL) /GX /W3 /I $(INCLUDE) /I$(INCLUDE_LIB_LOG) /I$(INCLUDE_MYSQL) /c /Fo$(DEBUG)/ ../Mysql.cpp

$(CL) /GX /W3 /I $(INCLUDE) /I$(INCLUDE_LIB_LOG) /I$(INCLUDE_MYSQL) /c /Fo$(DEBUG)/ ../Connection.cpp

$(CL) /GX /W3 /I $(INCLUDE) /I$(INCLUDE_LIB_LOG) /I$(INCLUDE_MYSQL) /c /Fo$(DEBUG)/ ../MysqlConnection.cpp

$(CL) /GX /W3 /I $(INCLUDE) /I$(INCLUDE_LIB_LOG) /I$(INCLUDE_MYSQL) /c /Fo$(DEBUG)/ ../MysqlStatement.cpp

$(CL) /GX /W3 /I $(INCLUDE) /I$(INCLUDE_LIB_LOG) /I$(INCLUDE_MYSQL) /c /Fo$(DEBUG)/ ../MysqlResultSet.cpp

$(CL) /GX /W3 /I $(INCLUDE) /I$(INCLUDE_LIB_LOG) /I$(INCLUDE_MYSQL) /c /Fo$(DEBUG)/ ../Mysql.cpp

$(CL) /GX /W3 /I $(INCLUDE) /I$(INCLUDE_LIB_LOG) /I$(INCLUDE_MYSQL) /c /Fo$(DEBUG)/ MysqlTest.cpp

#$(CL) /GX /W3 /I $(INCLUDE) /c StdAfx.cpp

#$(CL) /GX /W3 /I $(INCLUDE) /c *.cpp

#$(CL) /GX /W3 /I $(INCLUDE) /c /Fo$(DEBUG)/ *.cpp

#lib /nologo log.obj /out:./liblog.lib

$(LINK) /LIBPATH:$(LIB) /LIBPATH:$(LIB_LIB_LOG) /LIBPATH:$(LIB_MYSQL) /OUT:$(DEBUG)/MysqlTest.exe $(DEBUG)/*.obj

#$(LINK) /DLL /LIBPATH:$(LIB) /OUT:$(DEBUG)/liblog.dll *.obj

#$(LINK) /DLL /LIBPATH:$(LIB) /OUT:$(DEBUG)/liblog.dll $(DEBUG)/*.obj

# $(LINK) *.obj /LIBPATH:"D:\usr\bin\Microsoft Visual Studio\VC98\Lib"

cp ../liblog.dll $(DEBUG)/

clean:

rm -Rf ./*.bak

rm -Rf ./*.o

rm -Rf ./*.obj

rm -Rf ./*.exe

rm -Rf ../Debug/*

VC命令行环境下生成.DLL, .LIB库

创建make文件

Makefile.nmake

make文件内容

DEBUG=./Debug

liblog.lib:

#"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\cl.exe" /GX /W3 /I "D:\usr\bin\Microsoft Visual Studio\VC98\Include" /c log.cpp

#"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\cl.exe" /GX /W3 /I "D:\usr\bin\Microsoft Visual Studio\VC98\Include" /c liblog.cpp

"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\cl.exe" /GX /W3 /I "D:\usr\bin\Microsoft Visual Studio\VC98\Include" /c *.cpp

#lib /nologo log.obj /out:./liblog.lib

#"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\link.exe" /DLL /LIBPATH:"D:\usr\bin\Microsoft Visual Studio\VC98\Lib" /OUT:$(DEBUG)/liblog.dll log.obj

"D:\usr\bin\Microsoft Visual Studio\VC98\Bin\link.exe" /DLL /LIBPATH:"D:\usr\bin\Microsoft Visual Studio\VC98\Lib" /OUT:$(DEBUG)/liblog.dll *.obj

# "D:\usr\bin\Microsoft Visual Studio\VC98\Bin\link.exe" *.obj /LIBPATH:"D:\usr\bin\Microsoft Visual Studio\VC98\Lib"

命令行下MAKE

nmake /f Makefile.nmake

wxWidgets

第一个简单的程序

下面是一个完整的程序，这是一个C++程序，这个程序中没有看到有入口函数。

#include "wx/wx.h"

IMPLEMENT_APP(wxApp)

$ `wx-config --cxx` -c `wx-config --cxxflags --unicode=yes --static=no --toolkit=osx_cocoa --version=3.0` window_test.cpp -o window_test.o

$ `wx-config --cxx` -o window_test window_test.o `wx-config --unicode=yes --static=no --toolkit=osx_cocoa --version=3.0 --libs core,base`

可以通过以下命令看下程序是怎样的

$ `wx-config --cxx` -E `wx-config --cxxflags --unicode=yes --static=no --toolkit=osx_cocoa --version=3.0` window_test.cpp -o window_test.i

* int main(int argc, char **argv)

* {

* ;

* return wxEntry(argc, argv);

* }

* wxApp& wxGetApp()

* {

* return *static_cast<wxApp*>(wxApp::GetInstance());

* }

* wxAppConsole *wxCreateApp()

* {

* wxAppConsole::CheckBuildOptions("3" "." "0" " (" "wchar_t" ",compiler with C++ ABI " "1002" ",wx containers" ",compatible with 2.8" ")", "your program");

* return new wxApp;

* }

* wxAppInitializer wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp);

窗口

#include "wx/wx.h"

class MyApp : public wxApp
{
public:
  virtual bool OnInit();
};

class MyFrame : public wxFrame
{
public:
  MyFrame(const wxString& title);

	void OnExit(wxCommandEvent& WXUNUSED(event)) { Close(); }
private:
	
  wxDECLARE_EVENT_TABLE();
};

wxBEGIN_EVENT_TABLE(MyFrame, wxFrame)
	EVT_MENU(wxID_EXIT, MyFrame::OnExit)
wxEND_EVENT_TABLE()

IMPLEMENT_APP(MyApp)

bool MyApp::OnInit()
{
  if (! wxApp::OnInit())
    return false;

  MyFrame *frame = new MyFrame("主窗口");
  frame->Show(true);

  return true;
}

MyFrame::MyFrame(const wxString& title) : wxFrame(NULL, wxID_ANY, title, wxDefaultPosition, wxSize(500, 400))
{
	
}

工具

wx-config

分享到：

Tree | 图像处理

2012-08-26 20:55
浏览 776
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

Windows 编程

Windows Win32编程 https://www.iteye.com/blog/lobin-2516633

Windows MFC编程 https://www.iteye.com/blog/lobin-2516413

C: Windows编程: 第三章 TC https://www.iteye.com/blog/lobin-2439914

编写静态链接库

线程

C Run-Time Libraries (CRT)

C Run-Time Library _beginthread， _beginthreadex to create thread

自定义控制台窗口图标

中断

中断处理函数

线程

C++：线程封装

C++ Thread class

Windows下C/C++ 多线程同步（mutex）

Windows下C/C++ 多线程同步（event）

Windows下C/C++ 多线程同步

Windows下网络编程Socket定义：WINSOCK2.H头文件SOCKET

VC下相关工具

Makefile

wxWidgets

窗口

工具

评论

发表评论

相关推荐

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

Windows 编程

Windows Win32编程 https://www.iteye.com/blog/lobin-2516633

Windows MFC编程 https://www.iteye.com/blog/lobin-2516413

C: Windows编程: 第三章 TC https://www.iteye.com/blog/lobin-2439914

编写静态链接库

线程

C Run-Time Libraries (CRT)

C Run-Time Library _beginthread， _beginthreadex to create thread

自定义控制台窗口图标

中断

中断处理函数

线程

C++：线程封装

C++ Thread class

Windows下C/C++ 多线程同步（mutex）

Windows下C/C++ 多线程同步（event）

Windows下C/C++ 多线程同步

Windows下网络编程Socket定义：WINSOCK2.H头文件SOCKET

VC下相关工具

Makefile

wxWidgets

窗口

工具

评论

发表评论

相关推荐

C: 类型转换

C: 类型转换

C: lvalue & rvalue

C: lvalue & rvalue

C: 标准库

C: 标准库

C: 语句

C: 语句

C: 表达式求值

C: 表达式求值

第9章 C++ 引用

第23章 C++ 虚表

第22章 C++ 对象布局

C: 运算符

第30章 C++ 模板

第18章 C++ 重载

第19章 C++ 类和对象

第21章 C++ 虚函数

第20章 C++ 继承

第8章 C++lvalue&rvalue

最近访客更多访客>>