C++博客- C++ 技术中心-随笔分类-Windows 编程

异常和异常处理（windows平台）

C++技术中心 — Wed, 26 Nov 2014 07:12:00 GMT

【翻译】异常和异常处理（windows平台）

翻译的不好，莫怪。

原文地址： http://crashrpt.sourceforge.net/docs/html/exception_handling.html#getting_exception_context

About Exceptions and Exception Handling

About Exception

当程序遇到一个异常或一个严重的错误时，通常意味着它不能继续正常运行并且需要停止执行。

例如，当遇到下列情况时，程序会出现异常：

程序访问一个不可用的内存地址（例如，NULL指针）；

l 无限递归导致的栈溢出；

l 向一个较小的缓冲区写入较大块的数据；

l 类的纯虚函数被调用；

l 申请内存失败（内存空间不足）；

l 一个非法的参数被传递给C++函数；

l C运行时库检测到一个错误并且需要程序终止执行。

有两种不同性质的异常：结构化异常(Structured Exception Handling, SEH)和类型化的C++异常。

SEH是为C语言设计的，但是他们也能够被用于C++。SEH异常由__try{}__except(){}结构来处理。SEH是VC++编译器特有的，因此如果你想要编写可移植的代码，就不应当使用SEH。

C++中类型化的异常是由try{}catch(){}结构处理的。例如（例子来自这里http://www.cplusplus.com/doc/tutorial/exceptions/）：

#include
using namespace std;

int main(){
     try{
        throw 20;
     }
     catch (int e){
        cout << "An exception occrred. Exception Nr. " << e << endl;
     }

     return 0;
}

结构化异常处理

当发生一个SEH异常时，你通常会看到一个意图向微软发送错误报告的弹出窗口。

你可以使用RaiseException()函数自己产生一个SEH异常。

你可以在你的代码中使用__try{}__except(Expression){}结构来捕获SEH异常。程序中的main()函数被这样的结构保护，因此默认地，所有未被处理的SEH异常都会被捕获。

例如：

#include <Windows.h>

int main(){
     int *p = NULL;  // pointer to NULL
     __try{
        // Guarded code
        *p = 13;    // causes an access violation exception;
     }
     __except(EXCEPTION_EXECUTE_HANDLER){  // Here is exception filter expression
        // Here is exception handler
        // Terminate program
        ExitProcess(1);
     }

     return 0;
}

每一个SEH异常都有一个与其相关联的异常码（exception code）。你可以使用GetExceptionCode()函数来获取异常码。你可以通过GetExceptionInformation()来获取异常信息。为了使用这些函数，你通常会像下面示例中一样定制自己的exception filter。

下面的例子说明了如何使用SEH exception filter。

int seh_filter(unsigned int code, struct _EXCEPTION_POINTERS *ep){
     // Generate error report
     // Execute exception handler
     return EXCEPTION_EXECUTE_HANDLER;
}

int main(){
     __try{
        // .. some buggy code here
     }
     __except(seh_filter(GetExceptionCode(), GetExceptionInformation())){
        // Terminate program
        ExitProcess(1);
     }

     return 0;
}

__try{}__exception(){}结构是面向C语言的，但是，你可以将一个SEH异常重定向到C++异常，并且你可以像处理C++异常一样处理它。我们可以使用C++运行时库中的_set_se_translator()函数来实现。

看一个MSDN中的例子（译者注：运行此例子需打开/EHa编译选项）：

#include <cstdio>

   #include
   #include

   void SEFunc();
   void trans_func(unsigned int, EXCEPTION_POINTERS *);

   class SE_Exception{
   private:
       unsigned int nSE;
   public:
       SE_Exception(){}
       SE_Exception(unsigned int n) : nSE(n){}
       ~SE_Exception() {}
       unsigned int getSeNumber(){ return nSE; }
   };

   int main(void){
       try{
          _set_se_translator(trans_func);
          SEFunc();
       }
       catch(SE_Exception e){
          printf("Caught a __try exception with SE_Exception.\n");
       }
   }

   void SEFunc(){
       __try{
          int x, y=0;
          x = 5 / y;
       }
       __finally{
          printf("In finally\n");
       }
   }

   void trans_func(unsigned int u, EXCEPTION_POINTERS* pExp){
       printf("In trans_func.\n");
       throw SE_Exception();
   }

你可能忘记对一些潜在的错误代码使用__try{}__catch(Expression){}结构进行保护，而这些代码可能会产生异常，但是这个异常却没有被你的程序所处理。不用担心，这个未被处理的SEH异常能够被unhandled Exception filter所捕获，我们可以使用SetUnhandledExceptionFilter()函数设置top-levelunhandled exception filter。

异常信息（异常发生时的CPU状态）通过EXCEPTION_POINTERS被传递给exception handler。

例如：

// crt_settrans.cpp

   // compile with: /EHa
   LONG WINAPI MyUnhandledExceptionFilter(PEXCEPTION_POINTERS pExceptionPtrs){
       // Do something, for example generate error report
       //..
       // Execute default exception handler next
       return EXCEPTION_EXECUTE_HANDLER;
   }

   void main(){
       SetUnhandledExceptionFilter(MyUnhandledExceptionFilter);
       // .. some unsafe code here
   }

top-level SEH exception handler对进程中的每个线程都起作用，因此在你的main()函数开头调用一次就够了。

top-level SEH exception handler在发生异常的线程的上下文中被调用。这会影响异常处理函数从异常中恢复的能力。

如果你的异常处理函数位于一个DLL中，那么在使用SetUnhandledExceptionFilter()函数时就要小心了。如果你的函数在程序崩溃时还未被加载，这种行为是不可预测的。

向量化异常处理（Vectored Exception Handling）

向量化异常处理(VEH)是结构化异常处理的一个扩展，它在Windows XP中被引入。

你可以使用AddVectoredExceptionHandler()函数添加一个向量化异常处理器，VEH的缺点是它只能用在WinXP及其以后的版本，因此需要在运行时检查AddVectoredExceptionHandler()函数是否存在。

要移除先前安装的异常处理器，可以使用RemoveVectoredExceptionHandler()函数。

VEH允许查看或处理应用程序中所有的异常。为了保持后向兼容，当程序中的某些部分发生SEH异常时，系统依次调用已安装的VEH处理器，直到它找到有用的SEH处理器。

VEH的一个优点是能够链接异常处理器(chain exception handlers)，因此如果有人在你之前安装了向量化异常处理器，你仍然能截获这些异常。

当你需要像调试器一样监事所有的异常时，使用VEH是很合适的。问题是你需要决定哪个异常需要处理，哪个异常需要跳过。 In program's code, some exceptions may be intentionally guarded by __try{}__except(){} construction, and handling such exceptions in VEH and not passing it to frame-based SEH handler, you may introduce bugs into application logics.

VEH目前没有被CrashRpt所使用。SetUnhandledExceptionFilter()更加适用，因为它是top-level SEH处理器。如果没有人处理异常，top-level SEH处理器就会被调用，并且你不用决定是否要处理这个异常。

CRT 错误处理

除了SEH异常和C++类型化异常，C运行库(C runtime libraries, CRT)也提供它自己的错误处理机制，在你的程序中也应该考虑使用它。

当CRT遇到一个未被处理的C++类型化异常时，它会调用terminate()函数。如果你想拦截这个调用并提供合适的行为，你应该使用set_terminate()函数设置错误处理器(error hanlder)。例如：

#include
   void my_terminate_handler()
   {
       // Abnormal program termination (terminate() function was called)
       // Do something here
       // Finally, terminate program
       std::cout << "terminate.\n";
       exit(1);
   }

   int main()
   {
       set_terminate(my_terminate_handler);

       terminate();

       return 0;
   }

Note：在多线程环境中，每个线程维护各自的unexpected和terminate函数。每个新线程需要安装自己的unexpected和terminate函数。因此，每个线程负责自己的unexpected和terminate处理器。

使用_set_purecall_handler()函数来处理纯虚函数调用。这个函数可以用于VC++2003及其后续版本。这个函数可以用于一个进程中的所有线程。例如（来源于MSDN）：

// compile with: /EHa

   // _set_purecall_handler.cpp
   // compile with: /W1
   #include
   #include
   #include

   class CDerived;
   class CBase{
   public:
       CBase(CDerived *derived): m_pDerived(derived) {};
       ~CBase();
       virtual void function(void) = 0;

       CDerived * m_pDerived;
   };

   class CDerived : public CBase{
   public:
       CDerived() : CBase(this) {};   // C4355
       virtual void function(void) {};
   };

   CBase::~CBase(){
       m_pDerived -> function();
   }

   void myPurecallHandler(void){
       printf("In _purecall_handler.");
       exit(0);
   }

   int _tmain(int argc, _TCHAR* argv[]){
       //_set_purecall_handler(myPurecallHandler);
       CDerived myDerived;
   }

使用_set_new_handler()函数处理内存分配失败。这个函数能够用于VC++2003及其后续版本。这个函数可以用于一个进程中的所有线程。也可以考虑使用_set_new_mode()函数来为malloc()函数定义错误时的行为。例如（来自MSDN）：

  // crt_settrans.cpp
  #include <new.h>
  int handle_program_memory_depletion( size_t ){
      // Your code
  }
  int main( void ){
      _set_new_handler( handle_program_memory_depletion );
      int *pi = new int[BIG_NUMBER];
  }

在VC++2003中，你能够使用_set_security_error_handler()函数来处理缓冲区溢出错误。这个函数已经被废弃，并且从之后VC++版本的CRT中移除。

当系统函数调用检测到非法的参数时，会使用_set_invalid_parameter_handler()函数来处理这种情况。这个函数能够用于VC++2005及其以后的版本。这个函数可用于进程中的所有线程。

例子（来源于MSDN）：

// compile with: /Zi /MTd

   #include
   #include
   #include   // For _CrtSetReportMode

   void myInvalidParameterHandler(const wchar_t* expression,
                               const wchar_t* function,
                               const wchar_t* file,
                               unsigned int line,
                               uintptr_t pReserved){
       wprintf(L"Invalid parameter detected in function %s."
          L" File: %s Line: %d\n", function, file, line);
       wprintf(L"Expression: %s\n", expression);
   }


   int main( ){
       char* formatString;

       _invalid_parameter_handler oldHandler, newHandler;
       newHandler = myInvalidParameterHandler;
       oldHandler = _set_invalid_parameter_handler(newHandler);

       // Disable the message box for assertions.
       _CrtSetReportMode(_CRT_ASSERT, 0);

       // Call printf_s with invalid parameters.
       formatString = NULL;
       printf(formatString);
       return 0;
   }

C++信号处理C++ Singal Handling

C++提供了被称为信号的中断机制。你可以使用signal()函数处理信号。

Visual C++提供了6中类型的信号：

l SIGABRT Abnormal termination

l SIGFPE Floating-point error

l SIGILL Illegal instruction

l SIGINT CTRL+C signal

l SIGSEGV Illegal storage access

l SIGTERM

MSDN中说SIGILL, SIGSEGV,和SIGTERM are not generated under Windows NT并且与ANSI相兼容。但是，如果你在主线程中设置SIGSEGV signal handler，CRT将会调用它，而不是调用SetUnhandledExceptionFilter()函数设置的SHE exception handler，全局变量_pxcptinfoptrs中包含了指向异常信息的指针。

_pxcptinfoptrs也会被用于SIGFPE handler中，而在所有其他的signal handlers中，它将会被设为NULL。

当一个floating point 错误发生时，例如除零错，CRT将调用SIGFPE signal handler。然而，默认情况下，不会产生float point 异常，取而代之的是，将会产生一个NaN或无穷大的数作为这种浮点数运算的结果。可以使用_controlfp_s()函数使得编译器能够产生floating point异常。

使用raise()函数，你可以人工地产生所有的6中信号。例如：

#include
   #include
   #include

   void sigabrt_handler(int){
       // Caught SIGABRT C++ signal
       // Terminate program
            std::cout << "handled.\n";
            exit(1);
   }

   int main(){
     signal(SIGABRT, sigabrt_handler);
     // Cause abort
     abort();
   }

Note:

虽然MSDN中没有详细地说明，但是你应该为你程序中的每个线程都安装SIGFPE, SIGILL和SIGSEGV signal hanlders。SIGABRT, SIGINT和SIGTERM signal hanlders对程序中的每个线程都起作用，因此你只需要在你的main函数中安装他们一次就够了。

获取异常信息 Retrieving Exception Information

译者注：这一小节不太懂，以后有时间再翻译

When an exception occurs you typically want to get the CPU state to determine the place in your code that caused the problem. You use the information to debug the problem. The way you retrieve the exception information differs depending on the exception handler you use.

In the SEH exception handler set with the SetUnhandledExceptionFilter() function, the exception information is retrieved from EXCEPTION_POINTERS structure passed as function parameter.

In __try{}__catch(Expression){} construction you retrieve exception information using GetExceptionInformation() intrinsic function and pass it to the SEH exception filter function as parameter.

In the SIGFPE and SIGSEGV signal handlers you can retrieve the exception information from the _pxcptinfoptrs global CRT variable that is declared in . This variable is not documented well in MSDN.

In other signal handlers and in CRT error handlers you have no ability to easily extract the exception information. I found a workaround used in CRT code (see CRT 8.0 source files, invarg.c, line 104).

The following code shows how to get current CPU state used as exception information.

#if _MSC_VER>=1300
   #include
   #endif

   #ifndef _AddressOfReturnAddress

   // Taken from: http://msdn.microsoft.com/en-us/library/s975zw7k(VS.71).aspx
   #ifdef __cplusplus
   #define EXTERNC extern "C"
   #else
   #define EXTERNC
   #endif

   // _ReturnAddress and _AddressOfReturnAddress should be prototyped before use
   EXTERNC void * _AddressOfReturnAddress(void);
   EXTERNC void * _ReturnAddress(void);

   #endif

   // The following function retrieves exception info

   void GetExceptionPointers(DWORD dwExceptionCode,
                             EXCEPTION_POINTERS** ppExceptionPointers)
   {
       // The following code was taken from VC++ 8.0 CRT (invarg.c: line 104)

       EXCEPTION_RECORD ExceptionRecord;
       CONTEXT ContextRecord;
       memset(&ContextRecord, 0, sizeof(CONTEXT));

   #ifdef _X86_

       __asm {
           mov dword ptr [ContextRecord.Eax], eax
               mov dword ptr [ContextRecord.Ecx], ecx
               mov dword ptr [ContextRecord.Edx], edx
               mov dword ptr [ContextRecord.Ebx], ebx
               mov dword ptr [ContextRecord.Esi], esi
               mov dword ptr [ContextRecord.Edi], edi
               mov word ptr [ContextRecord.SegSs], ss
               mov word ptr [ContextRecord.SegCs], cs
               mov word ptr [ContextRecord.SegDs], ds
               mov word ptr [ContextRecord.SegEs], es
               mov word ptr [ContextRecord.SegFs], fs
               mov word ptr [ContextRecord.SegGs], gs
               pushfd
               pop [ContextRecord.EFlags]
       }

       ContextRecord.ContextFlags = CONTEXT_CONTROL;
   #pragma warning(push)
   #pragma warning(disable:4311)
       ContextRecord.Eip = (ULONG)_ReturnAddress();
       ContextRecord.Esp = (ULONG)_AddressOfReturnAddress();
   #pragma warning(pop)
       ContextRecord.Ebp = *((ULONG *)_AddressOfReturnAddress()-1);


   #elif defined (_IA64_) || defined (_AMD64_)

       /* Need to fill up the Context in IA64 and AMD64. */
       RtlCaptureContext(&ContextRecord);

   #else  /* defined (_IA64_) || defined (_AMD64_) */

       ZeroMemory(&ContextRecord, sizeof(ContextRecord));

   #endif  /* defined (_IA64_) || defined (_AMD64_) */

       ZeroMemory(&ExceptionRecord, sizeof(EXCEPTION_RECORD));

       ExceptionRecord.ExceptionCode = dwExceptionCode;
       ExceptionRecord.ExceptionAddress = _ReturnAddress();


       EXCEPTION_RECORD* pExceptionRecord = new EXCEPTION_RECORD;
       memcpy(pExceptionRecord, &ExceptionRecord, sizeof(EXCEPTION_RECORD));
       CONTEXT* pContextRecord = new CONTEXT;
       memcpy(pContextRecord, &ContextRecord, sizeof(CONTEXT));

       *ppExceptionPointers = new EXCEPTION_POINTERS;
       (*ppExceptionPointers)->ExceptionRecord = pExceptionRecord;
       (*ppExceptionPointers)->ContextRecord = pContextRecord;
   }

Visual C++ Complier Flags

Visual C++编译器中有一些编译选项和异常处理有关。

在Project Properties->Configuration Properties->C/C++ ->Code Generation中可以找到这些选项。

异常处理模型Exception Handling Model

你可以为VC++编译器选择异常处理模型。选项/EHs(或者EHsc)用来指定同步异常处理模型，/EHa用来指定异步异常处理模型。可以查看下面参考小节的"/EH(Exception Handling Model)"以获取更多的信息。

Floating Point Exceptions

你可以使用/fp:except编译选项打开float point exceptions。

缓冲区安全检查Buffer Security Checks

你可以使用/GS(Buffer Security Check)选项来强制编译器插入代码以检查缓冲区溢出。缓冲区溢出指的是一大块数据被写入一块较小的缓冲区中。当检测到缓冲区溢出，CRT calls internal security handler that invokes Watson directly。

Note:

在VC++(CRT7.1)中，缓冲区溢出被检测到时，CRT会调用由_set_security_error_handler函数设置的处理器。然而，在之后的VC版本中这个函数被废弃。

从CRT8.0开始，你在你的代码中不能截获安全错误。当缓冲区溢出被检测到时，CRT会直接请求Watson，而不是调用unhandled exception filter。这样做是由于安全原因并且微软不打算改变这种行为。

更多的信息请参考如下链接

https://connect.microsoft.com/VisualStudio/feedback/details/101337/a-proposal-to-make-dr-watson-invocation-configurable

http://blog.kalmbachnet.de/?postid=75

异常处理和CRT链接Exception Handling and CRT Linkage

你的应用程序中的每个module（EXE, DLL）都需要链接CRT。你可以将CRT链接为多线程静态库(multi-threaded static library)或者多线程动态链接库(multi-threaded dynamic link library)。如果你设置了CRT error handlers，例如你设置了terminate handler, unexcepted handler, pure call handler, invalid parameter handler, new operator error handler or a signal handler，那么他们将只在你链接的CRT上运行，并且不会捕获其他CRT模块中的异常（如果存在的话），因为每个CRT模块都有它自己的内部状态。

多个工程中的module可以共享CRT DLL。这将使得被链接的CRT代码达到最小化，并且CRT DLL中的所有异常都会被立刻处理。这也是推荐使用multi-threaded CRT DLL作为CRT链接方式的原因。

C++技术中心 2014-11-26 15:12 发表评论

panel和wxBoxSizer

C++技术中心 — Sun, 28 Sep 2014 08:13:00 GMT

//1.加入boxSizer19
    wxBoxSizer* topSizer = new wxBoxSizer(wxVERTICAL);
    this->SetSizer(topSizer);



    wxPanel* upPanel = new wxPanel( this, ID_BOT_PANEL2 ,wxDefaultPosition, wxSize(800, 100));

    upPanel->SetBackgroundColour(*wxBLACK);//黑色背景

    wxPanel* centerPanel = new wxPanel( this, ID_BOT_PANEL3,wxDefaultPosition, wxSize(800, 100) );
    centerPanel->SetBackgroundColour(*wxWHITE);//白色背景

    wxPanel* bottomPanel = new wxPanel( this, ID_BOT_PANEL4, wxDefaultPosition, wxSize(800, 100));

    bottomPanel->SetBackgroundColour(*wxRED);//红色背景

    topSizer->Add(upPanel,
        1,                   //垂直方向可拉伸
        wxEXPAND|            //水平方向自动填充
        wxALL,               //四周都有边框
        10                   //边框宽度为10
        );


    topSizer->Add(centerPanel,0,wxEXPAND);
    topSizer->Add(bottomPanel,0,wxEXPAND);

C++技术中心 2014-09-28 16:13 发表评论

关于warning C4819

C++技术中心 — Mon, 12 Nov 2012 02:00:00 GMT

编译VC++程序的时候出现如下提示警告：

warning C4819: The file contains a character that cannot be represented in the current code page (936). Save the file in Unicode format to prevent data loss

因为只是一个warning，不影响正常编译，所以并没有引起大家多大的关注。我一开始的时候也是如此。但是后来出现的次数多了，发现这个警告和在程序Debug的时候
无法停在断点，刷刷刷就过去了根本无法进行Debug。而罪魁祸首就是这个warning，改正了这个warning就能进行Debug了。

下面讲述我是怎么消除这个警告的。

这个警告的意思是：在该文件中有一个或多个字符不是Unicode字符！要求把这个字符变成Unicode字符。

难题：在编译信息里并没有提示是哪个字符，或者是在哪一行里出现的该字符。查找起来非常的难，甚至是不可能的任务！

我在网络上找了好多资料都没有找到解决方法。因为大家都不注意这个不影响编译的警告。后来在一个国外的网站上找到了解决的方法。很简单，这个方法根本不需要知道具体是哪个字符在捣鬼！

解决方法：打开出现warning的文件，Ctrl+A全选，然后在文件菜单：file->advanced save options ，在弹出的选项中选择新的编码方式为：UNICODE codepage 1200 ，点击确定，问题就解决了。

C++技术中心 2012-11-12 10:00 发表评论

Memcache存储大数据的问题

C++技术中心 — Fri, 19 Oct 2012 09:20:00 GMT

Memcached存储单个item最大数据是在1MB内，如果数据超过1M,存取set和get是都是返回false，而且引起性能的问题。

我们之前对排行榜的数据进行缓存，由于排行榜在我们所有sql select查询里面占了30%，而且我们排行榜每小时更新一次，所以必须对数据做缓存。为了清除缓存方便，把所有的用户的数据放在同一key中，由于memcached:set的时候没有压缩数据。在测试服测试的时候，没发现问题，当上线的时候，结果发现，在线人数刚刚490人的时候，服务器load average飘到7.9。然后我们去掉缓存，一下子就下降到0.59。

所以Memcahce不适合缓存大数据，超过1MB的数据，可以考虑在客户端压缩或拆分到多个key中。大的数据在进行load和uppack到内存的时候需要花很长时间，从而降低服务器的性能。

Memcached支持最大的存储对象为1M。这个值由其内存分配机制决定的。

memcached默认情况下采用了名为Slab Allocator的机制分配、管理内存。在该机制出现以前，内存的分配是通过对所有记录简单地进行malloc和free来进行的。但是，这种方式会导致内存碎片，加重操作系统内存管理器的负担，最坏的情况下，会导致操作系统比memcached进程本身还慢。Slab Allocator就是为解决该问题而诞生的。Slab Allocator的基本原理是按照预先规定的大小，将分配的内存分割成特定长度的块，以完全解决内存碎片问题.

今天（2012-03-16）我们重新测试了memcached ::set的数据大小。可能是我们用php的memcached扩展是最新版，set数据的时候是默认压缩的。set 数据：

[plain] view plain copy print ?

$ac = new memcahed();
$data = str_repeat('a', 1024* 1024); //1M的数据
$r = $ac->set('key', $data, 9999);
//或者
$data = str_repeat('a', 1024* 1024*100);//100M的数据
$r = $ac->set('key', $data, 9999);

$ac = new memcahed();
$data = str_repeat('a', 1024* 1024); //1M的数据
$r  =  $ac->set('key', $data, 9999);
//或者
$data = str_repeat('a', 1024* 1024*100);//100M的数据
$r  =  $ac->set('key', $data, 9999);

不论是1M的数据还是100M的数据，都能set成功。后来我发现，memcachedset数据的时候是默认压缩的。由于这个这个是重复的字符串，压缩率高达1000倍。因此100M的数据压缩后实际也就100k而已。

当我设置：

[plain] view plain copy print ?

$ac->setOption(memcahed::OPT_COMPRESSION,0); //不压缩存储数据。
$data = str_repeat('a', 1024* 1024); //1M数据
$r = $ac->set('key', $data, 9999);//1M的数据set不成功。

$ac->setOption(memcahed::OPT_COMPRESSION,0); //不压缩存储数据。
$data = str_repeat('a', 1024* 1024); //1M数据
$r  =  $ac->set('key', $data, 9999);//1M的数据set不成功。

也就是说memcached server不能存储超过1M的数据，但是经过客户端压缩数据后，只要小于1M的数据都能存储成功。

memcached相关知识：

1、memcached的基本设置
1）启动Memcache的服务器端
# /usr/local/bin/memcached -d -m 10 -u root -l 192.168.0.200 -p 12000 -c 256 -P /tmp/memcached.pid

-d选项是启动一个守护进程，
-m是分配给Memcache使用的内存数量，单位是MB，我这里是10MB，
-u是运行Memcache的用户，我这里是root，
-l是监听的服务器IP地址，如果有多个地址的话，我这里指定了服务器的IP地址192.168.0.200，
-p是设置Memcache监听的端口，我这里设置了12000，最好是1024以上的端口，
-c选项是最大运行的并发连接数，默认是1024，我这里设置了256，按照你服务器的负载量来设定，
-P是设置保存Memcache的pid文件，我这里是保存在 /tmp/memcached.pid，

2）如果要结束Memcache进程，执行：

# kill `cat /tmp/memcached.pid`

哈希算法将任意长度的二进制值映射为固定长度的较小二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该

段落的一个字母，随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入，在计算上是不可能的。

2、适用memcached的业务场景？

1）如果网站包含了访问量很大的动态网页，因而数据库的负载将会很高。由于大部分数据库请求都是读操作，那么memcached可以显著地减小数据库负载。

2）如果数据库服务器的负载比较低但CPU使用率很高，这时可以缓存计算好的结果（ computed objects ）和渲染后的网页模板（enderred templates）。

3）利用memcached可以缓存session数据、临时数据以减少对他们的数据库写操作。

4）缓存一些很小但是被频繁访问的文件。

5）缓存Web 'services'（非IBM宣扬的Web Services，译者注）或RSS feeds的结果.。

3、不适用memcached的业务场景？

1）缓存对象的大小大于1MB

Memcached本身就不是为了处理庞大的多媒体（large media）和巨大的二进制块（streaming huge blobs）而设计的。

2）key的长度大于250字符

3）虚拟主机不让运行memcached服务

如果应用本身托管在低端的虚拟私有服务器上，像vmware, xen这类虚拟化技术并不适合运行memcached。Memcached需要接管和控制大块的内存，如果memcached管理的内存被OS或 hypervisor交换出去，memcached的性能将大打折扣。

4）应用运行在不安全的环境中

Memcached为提供任何安全策略，仅仅通过telnet就可以访问到memcached。如果应用运行在共享的系统上，需要着重考虑安全问题。

5）业务本身需要的是持久化数据或者说需要的应该是database

4、不能能够遍历memcached中所有的item

这个操作的速度相对缓慢且阻塞其他的操作（这里的缓慢时相比memcached其他的命令）。memcached所有非调试（non-debug）命令，例如add, set, get, fulsh等无论

memcached中存储了多少数据，它们的执行都只消耗常量时间。任何遍历所有item的命令执行所消耗的时间，将随着memcached中数据量的增加而增加。当其他命令因为等待（遍历所有item的命令执行完毕）而不能得到执行，因而阻塞将发生。

5、 memcached能接受的key的最大长度是250个字符

memcached能接受的key的最大长度是250个字符。需要注意的是，250是memcached服务器端内部的限制。如果使用的Memcached客户端支持"key的前缀"或类似特性，那么key（前缀+原始key）的最大长度是可以超过250个字符的。推荐使用较短的key，这样可以节省内存和带宽。

6、单个item的大小被限制在1M byte之内

因为内存分配器的算法就是这样的。

详细的回答：

1）Memcached的内存存储引擎，使用slabs来管理内存。内存被分成大小不等的slabs chunks（先分成大小相等的slabs，然后每个slab被分成大小相等chunks，不同slab的chunk大小是不相等的）。chunk的大小依次从一个最小数开始，按某个因子增长，直到达到最大的可能值。如果最小值为400B，最大值是1MB，因子是1.20，各个slab的chunk的大小依次是：

slab1 - 400B；slab2 - 480B；slab3 - 576B ...slab中chunk越大，它和前面的slab之间的间隙就越大。因此，最大值越大，内存利用率越低。Memcached必须为每个slab预先分配内存，因此如果设置了较小的因子和较大的最大值，会需要为Memcached提供更多的内存。

2）不要尝试向memcached中存取很大的数据，例如把巨大的网页放到mencached中。因为将大数据load和unpack到内存中需要花费很长的时间，从而导致系统的性能反而不好。如果确实需要存储大于1MB的数据，可以修改slabs.c：POWER_BLOCK的值，然后重新编译memcached；或者使用低效的malloc/free。另外，可以使用数据库、MogileFS等方案代替Memcached系统。

7、 memcached的内存分配器是如何工作的？为什么不适用malloc/free！？为何要使用slabs？

实际上，这是一个编译时选项。默认会使用内部的slab分配器，而且确实应该使用内建的slab分配器。最早的时候，memcached只使用malloc/free来管理内存。然而，这种方式不能与OS的内存管理以前很好地工作。反复地malloc/free造成了内存碎片，OS最终花费大量的时间去查找连续的内存块来满足malloc的请求，而不是运行memcached进程。slab分配器就是为了解决这个问题而生的。内存被分配并划分成chunks，一直被重复使用。因为内存被划分成大小不等的slabs，如果item的大小与被选择存放它的slab不是很合适的话，就会浪费一些内存。

8、memcached对item的过期时间有什么限制？

item对象的过期时间最长可以达到30天。memcached把传入的过期时间（时间段）解释成时间点后，一旦到了这个时间点，memcached就把item置为失效状态，这是一个简单但obscure的机制。

9、什么是二进制协议，是否需要关注？

二进制协议尝试为端提供一个更有效的、可靠的协议，减少客户端/服务器端因处理协议而产生的CPU时间。根据Facebook的测试，解析ASCII协议是memcached中消耗CPU时间最多的

环节。

10、 memcached的内存分配器是如何工作的？为什么不适用malloc/free！？为何要使用slabs？

11、memcached是原子的吗？

所有的被发送到memcached的单个命令是完全原子的。如果您针对同一份数据同时发送了一个set命令和一个get命令，它们不会影响对方。它们将被串行化、先后执行。即使在多线程模式，所有的命令都是原子的。然是，命令序列不是原子的。如果首先通过get命令获取了一个item，修改了它，然后再把它set回memcached，系统不保证这个item没有被其他进程（process，未必是操作系统中的进程）操作过。memcached 1.2.5以及更高版本，提供了gets和cas命令，它们可以解决上面的问题。如果使用gets命令查询某个key的item，memcached会返回该item当前值的唯一标识。如果客户端程序覆写了这个item并想把它写回到memcached中，可以通过cas命令把那个唯一标识一起发送给memcached。如果该item存放在memcached中的唯一标识与您提供的一致，写操作将会成功。如果另一个进程在这期间也修改了这个item，那么该item存放在memcached中的唯一标识将会改变，写操作就会

失败。

Windows下的Memcache安装：
1. 下载memcache的windows稳定版，解压放某个盘下面，比如在c:/memcached
2. 在终端（也即cmd命令界面）下输入 ‘c:/memcached/memcached.exe -d install’ 安装
3. 再输入： ‘c:/memcached/memcached.exe -d start’ 启动。NOTE: 以后memcached将作为windows的一个服务每次开机时自动启动。这样服务器端已经安装完毕了。

/usr/local/memcached/bin/memcached -u root -d -m 3072 -l 192.168.121.130 -p 50008 -U 0 -P /var/run/memcache.pid

C++技术中心 2012-10-19 17:20 发表评论

memcached的删除机制和发展方向

C++技术中心 — Mon, 08 Oct 2012 01:39:00 GMT

memcached全面剖析–3.memcached的删除机制和发展方向

下面是《memcached全面剖析》的第三部分。

发表日：2008/7/16
作者：前坂徹(Toru Maesaka)
原文链接：http://gihyo.jp/dev/feature/01/memcached/0003

前几次的文章在这里：

第1次：http://tech.idv2.com/2008/07/10/memcached-001/
第2次：http://tech.idv2.com/2008/07/11/memcached-002/

memcached是缓存，所以数据不会永久保存在服务器上，这是向系统中引入memcached的前提。本次介绍memcached的数据删除机制，以及memcached的最新发展方向——二进制协议（Binary Protocol）和外部引擎支持。

memcached在数据删除方面有效利用资源

数据不会真正从memcached中消失

上次介绍过，memcached不会释放已分配的内存。记录超时后，客户端就无法再看见该记录（invisible，透明），其存储空间即可重复使用。

Lazy Expiration

memcached内部不会监视记录是否过期，而是在get时查看记录的时间戳，检查记录是否过期。这种技术被称为lazy（惰性）expiration。因此，memcached不会在过期监视上耗费CPU时间。

LRU：从缓存中有效删除数据的原理

memcached会优先使用已超时的记录的空间，但即使如此，也会发生追加新记录时空间不足的情况，此时就要使用名为 Least Recently Used（LRU）机制来分配空间。顾名思义，这是删除“最近最少使用”的记录的机制。因此，当memcached的内存空间不足时（无法从slab class获取到新的空间时），就从最近未被使用的记录中搜索，并将其空间分配给新的记录。从缓存的实用角度来看，该模型十分理想。

不过，有些情况下LRU机制反倒会造成麻烦。memcached启动时通过“-M”参数可以禁止LRU，如下所示：

$ memcached -M -m 1024

启动时必须注意的是，小写的“-m”选项是用来指定最大内存大小的。不指定具体数值则使用默认值64MB。

指定“-M”参数启动后，内存用尽时memcached会返回错误。话说回来，memcached毕竟不是存储器，而是缓存，所以推荐使用LRU。

memcached的最新发展方向

memcached的roadmap上有两个大的目标。一个是二进制协议的策划和实现，另一个是外部引擎的加载功能。

关于二进制协议

使用二进制协议的理由是它不需要文本协议的解析处理，使得原本高速的memcached的性能更上一层楼，还能减少文本协议的漏洞。目前已大部分实现，开发用的代码库中已包含了该功能。memcached的下载页面上有代码库的链接。

http://danga.com/memcached/download.bml

二进制协议的格式

协议的包为24字节的帧，其后面是键和无结构数据（Unstructured Data）。实际的格式如下（引自协议文档）：

 Byte/     0       |       1       |       2       |       3       |   
    /              |               |               |               |   
   |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|
   +---------------+---------------+---------------+---------------+
  0/ HEADER                                                        /   
   /                                                               /   
   /                                                               /   
   /                                                               /   
   +---------------+---------------+---------------+---------------+
 24/ COMMAND-SPECIFIC EXTRAS (as needed)                           /   
  +/  (note length in th extras length header field)               /   
   +---------------+---------------+---------------+---------------+
  m/ Key (as needed)                                               /   
  +/  (note length in key length header field)                     /   
   +---------------+---------------+---------------+---------------+
  n/ Value (as needed)                                             /   
  +/  (note length is total body length header field, minus        /   
  +/   sum of the extras and key length body fields)               /   
   +---------------+---------------+---------------+---------------+
  Total 24 bytes

如上所示，包格式十分简单。需要注意的是，占据了16字节的头部(HEADER)分为请求头（Request Header）和响应头（Response Header）两种。头部中包含了表示包的有效性的Magic字节、命令种类、键长度、值长度等信息，格式如下：

Request Header

 Byte/     0       |       1       |       2       |       3       |
    /              |               |               |               |
   |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|
   +---------------+---------------+---------------+---------------+
  0| Magic         | Opcode        | Key length                    |
   +---------------+---------------+---------------+---------------+
  4| Extras length | Data type     | Reserved                      |
   +---------------+---------------+---------------+---------------+
  8| Total body length                                             |
   +---------------+---------------+---------------+---------------+
 12| Opaque                                                        |
   +---------------+---------------+---------------+---------------+
 16| CAS                                                           |
   |                                                               |
   +---------------+---------------+---------------+---------------+

Response Header

 Byte/     0       |       1       |       2       |       3       |
    /              |               |               |               |
   |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|
   +---------------+---------------+---------------+---------------+
  0| Magic         | Opcode        | Key Length                    |
   +---------------+---------------+---------------+---------------+
  4| Extras length | Data type     | Status                        |
   +---------------+---------------+---------------+---------------+
  8| Total body length                                             |
   +---------------+---------------+---------------+---------------+
 12| Opaque                                                        |
   +---------------+---------------+---------------+---------------+
 16| CAS                                                           |
   |                                                               |
   +---------------+---------------+---------------+---------------+

如希望了解各个部分的详细内容，可以checkout出memcached的二进制协议的代码树，参考其中的docs文件夹中的protocol_binary.txt文档。

HEADER中引人注目的地方

看到HEADER格式后我的感想是，键的上限太大了！现在的memcached规格中，键长度最大为250字节，但二进制协议中键的大小用2字节表示。因此，理论上最大可使用65536字节（2¹⁶）长的键。尽管250字节以上的键并不会太常用，二进制协议发布之后就可以使用巨大的键了。

二进制协议从下一版本1.3系列开始支持。

外部引擎支持

我去年曾经试验性地将memcached的存储层改造成了可扩展的（pluggable）。

http://alpha.mixi.co.jp/blog/?p=129

MySQL的Brian Aker看到这个改造之后，就将代码发到了memcached的邮件列表。memcached的开发者也十分感兴趣，就放到了roadmap中。现在由我和memcached的开发者Trond Norbye协同开发（规格设计、实现和测试）。和国外协同开发时时差是个大问题，但抱着相同的愿景，最后终于可以将可扩展架构的原型公布了。代码库可以从memcached的下载页面上访问。

外部引擎支持的必要性

世界上有许多memcached的派生软件，其理由是希望永久保存数据、实现数据冗余等，即使牺牲一些性能也在所不惜。我在开发memcached之前，在mixi的研发部也曾经考虑过重新发明memcached。

外部引擎的加载机制能封装memcached的网络功能、事件处理等复杂的处理。因此，现阶段通过强制手段或重新设计等方式使memcached和存储引擎合作的困难就会烟消云散，尝试各种引擎就会变得轻而易举了。

简单API设计的成功的关键

该项目中我们最重视的是API设计。函数过多，会使引擎开发者感到麻烦；过于复杂，实现引擎的门槛就会过高。因此，最初版本的接口函数只有13个。具体内容限于篇幅，这里就省略了，仅说明一下引擎应当完成的操作：

引擎信息（版本等）
引擎初始化
引擎关闭
引擎的统计信息
在容量方面，测试给定记录能否保存
为item（记录）结构分配内存
释放item（记录）的内存
删除记录
保存记录
回收记录
更新记录的时间戳
数学运算处理
数据的flush

对详细规格有兴趣的读者，可以checkout engine项目的代码，阅读器中的engine.h。

重新审视现在的体系

memcached支持外部存储的难点是，网络和事件处理相关的代码（核心服务器）与内存存储的代码紧密关联。这种现象也称为tightly coupled（紧密耦合）。必须将内存存储的代码从核心服务器中独立出来，才能灵活地支持外部引擎。因此，基于我们设计的API，memcached被重构成下面的样子：

重构之后，我们与1.2.5版、二进制协议支持版等进行了性能对比，证实了它不会造成性能影响。

在考虑如何支持外部引擎加载时，让memcached进行并行控制（concurrency control）的方案是最为容易的，但是对于引擎而言，并行控制正是性能的真谛，因此我们采用了将多线程支持完全交给引擎的设计方案。

以后的改进，会使得memcached的应用范围更为广泛。

总结

本次介绍了memcached的超时原理、内部如何删除数据等，在此之上又介绍了二进制协议和外部引擎支持等memcached的最新发展方向。这些功能要到1.3版才会支持，敬请期待！

这是我在本连载中的最后一篇。感谢大家阅读我的文章！

下次由长野来介绍memcached的应用知识和应用程序兼容性等内容。

C++技术中心 2012-10-08 09:39 发表评论

windows 查看连接数

C++技术中心 — Mon, 20 Aug 2012 11:54:00 GMT

netstat -ant | find "9339" > c:\aa.txt
netstat -aon|findstr "9050"

C++技术中心 2012-08-20 19:54 发表评论

CodeLite 出现中文乱码问题

C++技术中心 — Wed, 28 Mar 2012 08:13:00 GMT

1.选择工程->setting->Common Settings->Compiler->
的c++ Compiler options 与c Compiler Option中加入
-fexec-charset=GBK;

C++技术中心 2012-03-28 16:13 发表评论

一个封装好的线程类

C++技术中心 — Fri, 11 Mar 2011 06:45:00 GMT

一.创建线程函数
常用的创建线程的函数是CreateThread,还有MFC中的AfxBeginThread方法.另一种函数是_beginthreadex,
其实它在内部调用了CreateThread，在调用之前_beginthreadex做了很多的工作，从而使得它比CreateThread更
安全.所以一般使用_beginthreadex来创建线程.于是以下使用_beginthreadex函数来创建线程类.

二.线程类示例
1.Thread.h文件如下:

#ifndef _THREAD_H__
#define _THREAD_H__
#include <process.h>
#include <windows.h>

class CThread
{
public:
public:
    CThread();
    virtual ~CThread();

    BOOL StartThread();   //开始线程
    BOOL SuspendThread(); //挂起线程
    virtual BOOL Run();   //线程的入口
    BOOL StopThread();    //等待线程退出再返回

    static unsigned __stdcall start_address( void * obj);

public:
    HANDLE m_hthread;        //线程句柄
    HANDLE m_hEventSuspend;  //用于标识线程是工作,还是挂起状态
    BOOL m_status;           //线程状态,FALSE表示线程退出状态,TRUE表示未提出状态
    unsigned  m_thrdaddr;
};

#endif/*_THREAD_H__*/

2.Thread.cpp文件如下:

#include "Thread.h"

CThread::CThread()
{
    m_hEventSuspend = CreateEvent(0,TRUE,FALSE,NULL);//创建事件句柄,且为非激发状态
    m_status = TRUE;

    //创建线程
    m_hthread = (HANDLE)_beginthreadex(NULL,0,CThread::start_address,this,0,&m_thrdaddr);
}

CThread::~CThread()
{
    CloseHandle(m_hEventSuspend);
    CloseHandle( m_hthread );
}

BOOL CThread::StartThread()
{
    return SetEvent(m_hEventSuspend);
}

BOOL CThread::SuspendThread()
{
    return ResetEvent(m_hEventSuspend);
}

BOOL CThread::Run()
{
    return TRUE;
}

BOOL CThread::StopThread()
{
    m_status = FALSE;//将线程状态置为退出
    StartThread();   //把线程唤醒,以免挂死在休眠处
    WaitForSingleObject(m_hthread,INFINITE); //等待线程退出

    return TRUE;
}

unsigned __stdcall CThread::start_address( void * obj)
{
    CThread* pthread = static_cast<CThread*>(obj);

    while(pthread->m_status)
    {
        WaitForSingleObject(pthread->m_hEventSuspend,INFINITE);//控制挂起，运行
        //如果自动退出
        if (!pthread->Run())
            break;
    }
    _endthreadex(0);

    return 0;
}

三.线程类的使用
1. 新建一个win32控制台工程,代码如下:

#include "Thread.h"
#include <iostream>
#include <conio.h>

using namespace std;

class CMyThread:public CThread
{
public:
    BOOL Run()
    {
        cout<<"hello!"<<endl;
        Sleep(5000);
        return TRUE;
    }
};

int main(int argc,char *argv[])
{
    //创建线程
    CMyThread mythread;

    //让线程启动
    mythread.StartThread();

    //按任意键,线程挂起
    _getch();
    mythread.SuspendThread();
    cout<<"thread suspend"<<endl;

    //接任意键,线程停止
    _getch();
    mythread.StopThread();
    cout<<"thread stop"<<endl;

    //按任意键,程序退出
    _getch();

    return 0;
}

C++技术中心 2011-03-11 14:45 发表评论

静态链接库与动态链接库使用详解

C++技术中心 — Thu, 10 Mar 2011 07:48:00 GMT

一.静态库
         用通俗的话讲,静态库就是将代码编译到一个二进制文件下(通常扩展名为.LIB).然后客户
端调用程序,只需要包含相关的.h文件及LIB库文件一起链接到exe文件中.可执行程序发布后,不
再需要该.lib文件了.

二.动态库
   最终将编译出.lib与.dll文件. 注意.lib文件与上面的静态库虽然扩展名相同,但有本质的
   区别.动态库中的lib文件是动态库的引入库. 该引入库包含被DLL导出的函数和变量的"符号
   名".而静态库中的.lib包含了函数和数据,动态库的函数和数据是编译到.dll中.动态链接库调
   用方式分为隐式调用与显示调用(也称静态调用与动态调用)。

三.静态库的使用
1.下面来看看如何生成一个静态库

   (1)新建静态库工程,新建DllStaticLib.h及新建DllStaticLib.cpp文件
   (2)DllStaticLib.h代码如下：

   #ifndef _DLL_STATIC_LIB_H__
   #define _DLL_STATIC_LIB_H__

   extern "C"{
      int add(int x,int y);
   }

   #endif/*_DLL_STATIC_LIB_H__*/

(3)DllStaticLib.cpp代码如下:

   #include "DllStaticLib.h"
   #include "stdafx.h"

   int add(int x,int y)
   {
        return x+y;
   }

(4)最终生成DllStaticLib.lib静态库文件
2.调用静态库
(1)现在只要使用DllStaticLib.lib,DllStaticLib.h文件.
(注意让VC能搜索到该文件,设置VC相关的包含目录与库目录.

(2)调用代码如下:

#include "stdafx.h"
#include <conio.h>
#include "DllStaticLib.h"//要设置VC包含目录,以便编译时能找到头文件

//要设置VC库目录,以便编译链接时可以找到该DllStaticLib.lib
#pragma comment(lib,"DllStaticLib.lib")

int main(int argc, char* argv[])
{
    printf("%d\n",add(3,5));

    _getch();
    return 0;
}

四. 动态链接库的使用
1.生成动态链接库
(1)新建动态链接库工程,加入TestDll.h及TestDll.cpp文件
(2)TestDll.h代码如下:

#ifndef _TEST_DLL_H__
#define _TEST_DLL_H__

#ifdef TESTDLL_EXPORTS
#define TESTDLL_API __declspec(dllexport)
#else
#define TESTDLL_API __declspec(dllimport)
#endif

extern "C" TESTDLL_API int sum(int x,int y);

#endif/*_TEST_DLL_H__*/

(3)TestDll.cpp代码如下:

#include "TestDll.h"

int sum(int x,int y)
{
return x+y;
}

(3)注意,将工程中设置属性定义TESTDLL_EXPORTS宏,以便确定该工程为DLL导出
(4)最终生成TestDll.lib及TestDll.dll文件

2.隐式调用Dll库
(1)新建win32控制台工程,加入DllClient.cpp
(2)示例代码如下:

#include <iostream>
#include <conio.h>
#include "TestDll.h" //要设置VC包含目录,以便编译时能找到头文件
using namespace std;

//要设置VC库目录,以便编译链接时可以找到该DllStaticLib.lib
#pragma  comment(lib,"TestDll.lib")

int main(int argc,char *argv[])
{

    printf("%d\n",sum(8,9));
    _getch();
    return 0;
}

(3)说明,隐式调用需要lib文件,但是exe编译后,就不再需要lib,只需要dll文件即可.
以下显式调用不需要lib文件,只需要提供dll文件.随exe运行与结束装载或释放dll文件.

3.显式调用Dll库
(1)同上新建win32工程.加入cpp文件,代码如下:

#include <iostream>
#include <conio.h>
#include <windows.h>
using namespace std;

typedef int FUN_SUM(int x,int y);

int main(int argc,char *argv[])
{

    HINSTANCE hDll; //DLL句柄

    hDll = LoadLibrary(L"TestDll.dll");
    if (hDll != NULL)
    {
        FUN_SUM *sum = (FUN_SUM*)GetProcAddress(hDll, "sum");
        if(sum)
        {
            cout<<(*sum)(9,10)<<endl;
        }
        else
        {
            cout<<"获取sum函数指针失败!"<<endl;
        }

        FreeLibrary(hDll);
    }
    else
    {
        cout<<"装载TestDll.dll失败!"<<endl;
    }
    _getch();
    return 0;
}

(2)显式链接在程序运行中可以把DLL的内存动态映射到调用进程的地址空间。释放可按需释放,使用更灵活.

C++技术中心 2011-03-10 15:48 发表评论

内存映射文件

C++技术中心 — Wed, 09 Mar 2011 07:05:00 GMT

一.内存映射文件技术作用
1.使用内存映射文件来访问磁盘上的数据文件。这使你可以不必对文件执行 I / O操作，并且可以不必对文件内容进行缓存.
2.可以使用内存映射文件，使同一台计算机上运行的多个进程能够相互之间共享数据。windows确实提供了其他一些方法，
    以便在进程之间进行数据通信，但是这些方法都是使用内存映射文件来实现的，诸如使用SendMessage或者PostMessage，
    都在内部使用了内存映射文件.这使得内存映射文件成为单个计算机上的多个进程互相进行通信的最有效的方法。

二.相当函数介绍
  1. CreateFile函数
(1)作用:创建或打开下列对象，并返回一个可以用来访问这些对象的句柄(可以打开:文件,管道等)
  (2)函数原型:
   HANDLE CreateFile(
               LPCTSTR lpFileName,    //指向文件名的指针
               DWORD dwDesiredAccess,    //访问模式（写/读）
               DWORD dwShareMode,    //共享模式
               LPSECURITY_ATTRIBUTES lpSecurityAttributes, //指向安全属性的指针
              DWORD dwCreationDisposition,   //如何创建
              DWORD dwFlagsAndAttributes,   //文件属性
               HANDLE hTemplateFile    //用于复制文件句柄
      );
(3)参数介绍

(4)返回值
     如执行成功，则返回文件句柄。INVALID_HANDLE_VALUE表示出错，会设置GetLastError。即使函数成功，
     但若文件存在，且指定了CREATE_ALWAYS 或 OPEN_ALWAYS，GetLastError也会设为ERROR_ALREADY_EXISTS

2.CreateFileMapping
(1)为指定文件创建一个有名或无名的文件映象
(2)函数原型
HANDLE CreateFileMapping(
HANDLE hFile,              // 映射文件的句柄
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
                             // 安全描述符指针
DWORD flProtect,           // 对映射对象的保护
DWORD dwMaximumSizeHigh,   // 对象最大长度的高32位
DWORD dwMaximumSizeLow,    // 对象最大长度的低32位
LPCTSTR lpName             // 文件内存映射对象的名字
);

(3)参数说明
hFile：映射文件的句柄，文件的打开模式必须与flProtect参数指定的相一致；如果这个参数值为0xFFFFFFFF，
             那么必须在dwMaximumSizeHigh和dwMaximumSizeLow参数中指定映射对象的大小。并且将在操作系统
            虚拟内存页面替换文件中创建文件映射对象，而不是使用磁盘文件，同时必须给出这个映射对象的大小。
            文件映射对象通过副本，遗传或名字来共享。
lpFileMappingAttributes：安全描述符指针，决定返回句柄是否能被子进程继承，如果是NULL，那么子进程不能
                                              继承。WinNt中，如果是NULL，那么文件映射对象得到一个默认的安全描述符。
flProtect：为得到的文件试图指定保护模式，可以被设置为下列值：
     PAGE_READONLY ：只读属性，并且hFile对应的文件必须以GENERIC_READ形式打开。
     PAGE_READWRITE：可读可写属性，并且hFile对应的文件必须以GENERIC_READ 和 GENERIC_WRITE形式打开。
    PAGE_WRITECOPY：对可写区域复制后操作，并且hFile对应的文件必须以GENERIC_READ 和 GENERIC_WRITE形式打开。

dwMaximumSizeHigh，dwMaximumSizeLow：如果这两个参数为0，则文件映射对象的最大长度等于hFile指定的文件长度
lpName：文件映射对象的名字，如果这个名字已存在，则按照flProtect指定的来处理映射对象。如果此参数为空，则创
建一个无名字的文件映射对象。如果此参数的名字与系统事件的名字相同，则函数执行失败，GetLastError返回
ERROR_INVALID_HANDLE；

(4)返回值
数调用成功返回文件映射对象的句柄，如果文件映射对象已经存在则返回原有映射对象的句柄，GetLastError返回
ERROR_ALREADY_EXISTS。函数执行失败返回Null

3. MapViewOfFile
(1)在调用进程的地址空间映射一个文件视图
(2)函数原型
LPVOID MapViewOfFile(
HANDLE hFileMappingObject, // 已创建的文件映射对象句柄
DWORD dwDesiredAccess,      // 访问模式
DWORD dwFileOffsetHigh,     // 文件偏移的高32位
DWORD dwFileOffsetLow,      // 文件偏移的低32位
DWORD dwNumberOfBytesToMap // 映射视图的大小
);
(3)参数
    hFileMappingObject：由CreateFileMapping 或 OpenFileMapping 返回的文件映射对象句柄。
    dwDesiredAccess：      映射视图的访问模式，与创建文件映射对象的保护模式flProtect有关，可以被设置为下列值：
    FILE_MAP_WRITE：一个可读写属性的文件视图被创建，保护模式为PAGE_READWRITE
    FILE_MAP_READ ：一个只读属性的文件视图被创建，保护模式为PAGE_READWRITE 或 PAGE_READONLY
    FILE_MAP_ALL_ACCESS：与FILE_MAP_WRITE模式相同
    FILE_MAP_COPY：保护模式为PAGE_WRITECOPY时，得到一个视图文件，当你对视图文件写操作时，页面自动
                                           交换，并且你所做的修改不会损坏原始数据资料。
dwNumberOfBytesToMap：映射文件部分的大小，如果为0，则映射整个文件。
(4)返回值：如果成功返回返回映射视图的起始地址，如果失败返回NULL

4.UnmapViewOfFile
(1)删除文件的映射视图
(2)函数原型
BOOL UnmapViewOfFile(
LPCVOID lpBaseAddress // 映射视图起始地址
);
(3)参数
lpBaseAddress：映射视图起始地址，由 MapViewOfFile 函数 MapViewOfFileEx产生

(4)返回值:如果调用成功返回非零，并且所有指定地址内的脏页面会被写入硬盘。调用失败返回零。

5.FlushViewOfFile
(1)把文件映射视图中的修改的内容或全部写回到磁盘文件中
(2)函数原型
BOOL FlushViewOfFile(
LPCVOID lpBaseAddress, // 修改内容的起始地址
DWORD dwNumberOfBytesToFlush // 修改的字节数目
);
(3)返回值:函数执行成功返回非零。

6.MapViewOfFileEx
(1)在调用进程的地址空间映射一个文件视图，并且允许调用进程为映射视图指定特殊的内存地址
(2)函数原型:
LPVOID MapViewOfFileEx(
HANDLE hFileMappingObject, // 文件映射对象的句柄
DWORD dwDesiredAccess,      // 访问模式
DWORD dwFileOffsetHigh,     // 文件偏移的高32位
DWORD dwFileOffsetLow,      // 文件偏移的低32位
DWORD dwNumberOfBytesToMap, // 映射视图的大小
LPVOID lpBaseAddress        // 指定映射视图的其实内存地址
);
注意：
与MapViewOfFile用法相同，但是如果指定的内存地址空间大小不够，则函数执行失败。

7.OpenFileMapping
(1)打开一个已命名的文件映射对象
(2)函数原型
HANDLE OpenFileMapping(
DWORD dwDesiredAccess, // 访问模式
BOOL bInheritHandle,    // 继承标志
LPCTSTR lpName          // 文件映射对象名指针
);
(3)参数
dwDesiredAccess：访问模式与MapViewOfFile中的访问模式相同。
bInheritHandle：继承标志，是否可以被一个新的进程继承使用，如果为TRUE，就可以被一个新进程继承句柄。
(4)返回值
成功返回一个已命名的文件映射对象，失败返回NULL。

三. 以下是简单的操作示例

#include <Windows.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>

int main(int argc,char argv[])
{
    HANDLE hFile;
    OFSTRUCT opBuf;
    HANDLE hMapfile;
    HANDLE hMapview;
    char *recv;

    //1.创建或打开文件
    hFile = ::CreateFile("D:\\MapFileTest.txt",  GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile==0)
    {
        printf("open file failed!\n");
        return 1;
    }

    //2.为指定文件创建一个有名的文件映象
    hMapfile=CreateFileMapping((HANDLE)hFile,NULL,PAGE_READWRITE,0,3,"MapTest");
    if(hMapfile==NULL)
    {
        printf("mapping file failed!\n");
        return 1;
    }
    //关闭文件句柄
    CloseHandle((HANDLE)hFile);
    hFile=0;

    //3.在调用进程的地址空间映射一个文件视图
    hMapview=MapViewOfFile(hMapfile,FILE_MAP_WRITE,0,0,0);
    if(hMapview==NULL)
    {
        printf("mapping view failed!\n");
        return 1;
    }

    //往文件映射视图中写入数据
    recv=(char *)hMapview;
    printf("Mapping view's content is :%.10s \n",recv);
    strcpy(recv,"abc");

    //把文件映射视图中的修改的内容或全部写回到磁盘文件中
    FlushViewOfFile(recv,3);

    //4.删除文件的映射视图
    printf("Mapping view's content is :%.10s \n",recv);
    UnmapViewOfFile(hMapview);

    //关闭文件映象句柄
    CloseHandle(hMapfile);
    hMapfile = 0;

    _getch();
    return 0;
}

C++技术中心 2011-03-09 15:05 发表评论