自学教程：C++ FormatMessageA函数代码示例

 Win32ErrorLogMessage::~Win32ErrorLogMessage() {     const int error_message_buffer_size = 256;     char msgbuf[error_message_buffer_size];     DWORD flags = FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;     HMODULE hmod;     if(module_)     {         hmod = GetModuleHandleA(module_);         if(hmod)         {             flags |= FORMAT_MESSAGE_FROM_HMODULE;         }         else         {             // 导致Win32ErrorLogMessage嵌套, 由于module_是NULL不会再次进入这里,             // 所以不会死循环.             DPLOG(WARNING) << "Couldn't open module " << module_                 << " for error message query";         }     }     else     {         hmod = NULL;     }     DWORD len = FormatMessageA(flags, hmod, err_,         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),         msgbuf, sizeof(msgbuf)/sizeof(msgbuf[0]), NULL);     if(len)     {         while((len>0) && isspace(static_cast<unsigned char>(msgbuf[len-1])))         {             msgbuf[--len] = 0;         }         stream() << ": " << msgbuf;     }     else     {         stream() << ": Error " << GetLastError() << " while retrieving error "             << err_;     } }

    void acquirePathLock() {        string name = ( boost::filesystem::path( dbpath ) / "mongod.lock" ).string();#ifdef _WIN32        lockFileHandle = CreateFileA( name.c_str(), GENERIC_READ | GENERIC_WRITE,            0 /* do not allow anyone else access */, NULL,             OPEN_ALWAYS /* success if fh can open */, 0, NULL );        if (lockFileHandle == INVALID_HANDLE_VALUE) {            DWORD code = GetLastError();            char *msg;            FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,                NULL, code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),                (LPSTR)&msg, 0, NULL);            string m = msg;            str::stripTrailing(m, "/r/n");            uasserted( 13627 , str::stream() << "Unable to create/open lock file: " << name << ' ' << m << ". Is a mongod instance already running?" );        }        lockFile = _open_osfhandle((intptr_t)lockFileHandle, 0);#else        lockFile = open( name.c_str(), O_RDWR | O_CREAT , S_IRWXU | S_IRWXG | S_IRWXO );        if( lockFile <= 0 ) {            uasserted( 10309 , str::stream() << "Unable to create/open lock file: " << name << ' ' << errnoWithDescription() << " Is a mongod instance already running?" );        }        if (flock( lockFile, LOCK_EX | LOCK_NB ) != 0) {            close ( lockFile );            lockFile = 0;            uassert( 10310 ,  "Unable to lock file: " + name + ". Is a mongod instance already running?",  0 );        }#endif#ifdef _WIN32        uassert( 13625, "Unable to truncate lock file", _chsize(lockFile, 0) == 0);        writePid( lockFile );        _commit( lockFile );#else        uassert( 13342, "Unable to truncate lock file", ftruncate(lockFile, 0) == 0);        writePid( lockFile );        fsync( lockFile );        flushMyDirectory(name);#endif    }

char *err_strA(DWORD dw){	static char msgstr[256];    LPVOID lpMsgBuf;    FormatMessageA(        FORMAT_MESSAGE_ALLOCATE_BUFFER |        FORMAT_MESSAGE_FROM_SYSTEM |        FORMAT_MESSAGE_IGNORE_INSERTS,        NULL,        dw,        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),        (LPSTR) &lpMsgBuf,        0, NULL );    // Display the error message and exit the process    StringCchPrintfA(msgstr, ARRAYSIZE(msgstr), "%d: %s", dw, lpMsgBuf);	return msgstr;}

 const char* COMException::what() const {   if(!msg)   {     LPSTR readable_hr = nullptr;     FormatMessageA(       FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,       nullptr, hr, 0, reinterpret_cast<LPSTR>(&readable_hr), 0, nullptr);     if(readable_hr)     {       msg = FormatMessagef("%1!s! (%2!s!)", readable_hr, function);       LocalFree(readable_hr);     }     else     {       msg = FormatMessagef("HR 0x%1!08x! (%2!s!)", hr, function);     }   }   return msg ? msg : "COMException"; }

static std::string GetErrorMessage(DWORD error) {  std::string message;  LPVOID buffer = NULL;  DWORD flags = FORMAT_MESSAGE_ALLOCATE_BUFFER |                FORMAT_MESSAGE_FROM_SYSTEM |                FORMAT_MESSAGE_IGNORE_INSERTS;  DWORD lang_id = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);  DWORD result = FormatMessageA(flags, NULL, error, lang_id,                                reinterpret_cast<LPSTR>(&buffer),                                0, NULL);  if (result > 0) {    message.assign(StripNewLine(reinterpret_cast<char*>(buffer)));  }  LocalFree(buffer);  return message;}

const char* X_GetLastError(){#if defined WINDOWS || WIN32    char szBuf[256] = {0};	LPVOID lpMsgBuf;	DWORD dw = GetLastError();	FormatMessageA(		FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,		NULL,		dw,		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),		(LPSTR)&lpMsgBuf,		0, NULL);	return (const char*)lpMsgBuf;#else    extern int errno;    errno = 0;    return dlerror();#endif}

DLLEXPORT(char*) hresultString( HRESULT hr ){   static char msgbuf[256];   int len;   sprintf( msgbuf, "(0x%lx) ", hr );   len = strlen(msgbuf);   FormatMessageA(        FORMAT_MESSAGE_FROM_SYSTEM,        NULL,        hr,        MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),        msgbuf + len,        256,        NULL    );    return msgbuf;}

// Generic function to get last error message.// Call directly after the command or use the error num.// This function might change the error code.const char* GetLastErrorMsg(){	static const size_t buff_size = 255;#ifdef _WIN32	static __declspec(thread) char err_str[buff_size] = {};	FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, GetLastError(),		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),		err_str, buff_size, nullptr);#else	static __thread char err_str[buff_size] = {};	// Thread safe (XSI-compliant)	if (strerror_r(errno, err_str, buff_size))		return nullptr;#endif	return err_str;}

void win_perror(const char *str){    DWORD dwError = GetLastError();    LPVOID lpvMessageBuffer;    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |                  FORMAT_MESSAGE_FROM_SYSTEM |                  FORMAT_MESSAGE_IGNORE_INSERTS,                  NULL, dwError,                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),                  (LPSTR)&lpvMessageBuffer, 0, NULL);    //... now display this string    fprintf(stderr, "%s: %s/n", str, lpvMessageBuffer);        // Free the buffer allocated by the system    LocalFree(lpvMessageBuffer);}

LIBCOUCHSTORE_APIvoid couchstore_last_os_error(char* buf, size_t size) {    struct _os_error *err = get_os_error_store();#ifndef WINDOWS    snprintf(buf, size, "errno = %d: `%s'", err->errno_err, strerror(err->errno_err));#else    char* win_msg = NULL;    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |                   FORMAT_MESSAGE_FROM_SYSTEM |                   FORMAT_MESSAGE_IGNORE_INSERTS,                   NULL, err->win_err,                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),                   (LPTSTR) &win_msg,                   0, NULL);    snprintf(buf, size, "errno = %d: `%s', WINAPI error = %d: `%s'",             err->errno_err, strerror(err->errno_err),             err->win_err, win_msg);    LocalFree(win_msg);#endif}

static void TestDceErrorInqText (void){    char bufferInvalid [1024];    char buffer [1024]; /* The required size is not documented but would                         * appear to be 256.                         */    DWORD dwCount;    dwCount = FormatMessageA (FORMAT_MESSAGE_FROM_SYSTEM |               FORMAT_MESSAGE_IGNORE_INSERTS,              NULL, RPC_S_NOT_RPC_ERROR, 0, bufferInvalid,              sizeof(bufferInvalid)/sizeof(bufferInvalid[0]), NULL);    /* A random sample of DceErrorInqText */    /* 0 is success */    ok ((DceErrorInqTextA (0, (unsigned char*)buffer) == RPC_S_OK),            "DceErrorInqTextA(0...)/n");    /* A real RPC_S error */    ok ((DceErrorInqTextA (RPC_S_INVALID_STRING_UUID, (unsigned char*)buffer) == RPC_S_OK),            "DceErrorInqTextA(valid...)/n");    if (dwCount)    {        /* A message for which FormatMessage should fail         * which should return RPC_S_OK and the          * fixed "not valid" message         */        ok ((DceErrorInqTextA (35, (unsigned char*)buffer) == RPC_S_OK &&                    strcmp (buffer, bufferInvalid) == 0),                "DceErrorInqTextA(unformattable...)/n");        /* One for which FormatMessage should succeed but          * DceErrorInqText should "fail"         * 3814 is generally quite a long message         */        ok ((DceErrorInqTextA (3814, (unsigned char*)buffer) == RPC_S_OK &&                    strcmp (buffer, bufferInvalid) == 0),                "DceErrorInqTextA(deviation...)/n");    }    else        ok (0, "Cannot set up for DceErrorInqText/n");}

MEDUSA_NAMESPACE_BEGINstd::string Exception_System::ErrorCodeToMessage(void){  HLOCAL hLocal = nullptr;  if (FormatMessageA(    FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,    nullptr,    GetLastError(),    0x0,    (LPSTR)&hLocal,    0x0,    nullptr    ) == 0x0)    return "Unable to retrieve the exception message";  std::string Res = (LPCSTR)LocalLock(hLocal);  LocalFree(hLocal);  return Res;}

std::string GetLastErrorString() {	LPSTR lpBuffer = NULL;	std::string strError;	if(FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 					  NULL,					  GetLastError(),					  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),					  (LPSTR) &lpBuffer,					  0,					  NULL) != 0) {		strError = lpBuffer;		LocalFree( lpBuffer );	} else {		std::ostringstream buffer; //! Buffer for the log message excluding level, file and line.		buffer << "Unknown error (" << GetLastError() << ").";		strError = buffer.str();	}		return strError;}

void ipk_perror_win(unsigned long error){    if (error == 0)        return;    char* errmsg = NULL;    unsigned long hr = FormatMessageA(        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,        0U, error, LANG_NEUTRAL, (char *)&errmsg, 0U, NULL);    assert(hr > 0);    if (errmsg) {        _ipk_error_log("Chyba #%d: %s", error, errmsg);    }    else {        _ipk_error_log("Chyba #%d", error);    }    LocalFree(errmsg);}

static VOIDset_krberror(DWORD errCode, const SEC_CHAR* msg) {    SEC_CHAR* err;    DWORD status;    DWORD flags = (FORMAT_MESSAGE_ALLOCATE_BUFFER |                   FORMAT_MESSAGE_FROM_SYSTEM |                   FORMAT_MESSAGE_IGNORE_INSERTS);    status = FormatMessageA(flags,                            NULL,                            errCode,                            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),                            (LPTSTR)&err,                            0,                            NULL);    if (status) {        PyErr_Format(KrbError, "SSPI: %s: %s", msg, err);        LocalFree(err);    } else {        PyErr_Format(KrbError, "SSPI: %s", msg);    }}

void Library::getLastErrorMessage( std::string& message ){#ifdef CORAL_OS_WIN	LPVOID lpMsgBuf;	FormatMessageA(		FORMAT_MESSAGE_ALLOCATE_BUFFER |		FORMAT_MESSAGE_FROM_SYSTEM |		FORMAT_MESSAGE_IGNORE_INSERTS,		NULL,		GetLastError(),		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),		(LPTSTR)&lpMsgBuf,		0, NULL	);	message = (char*)lpMsgBuf;	LocalFree( lpMsgBuf );#else	const char* errorMsg = dlerror();	message = ( errorMsg == NULL ? "" : errorMsg );#endif}

char* tr_net_strerror(char* buf, size_t buflen, int err){    *buf = '/0';#ifdef _WIN32    DWORD len = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, buflen, NULL);    while (len > 0 && buf[len - 1] >= '/0' && buf[len - 1] <= ' ')    {        buf[--len] = '/0';    }#else    tr_strlcpy(buf, tr_strerror(err), buflen);#endif    return buf;}

char *win32_strerror(int inErrorCode)	{	static char buffer[1024];	DWORD       n;	memset(buffer, 0, sizeof(buffer));	n = FormatMessageA(			FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,			NULL,			(DWORD) inErrorCode,			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),			buffer,			sizeof(buffer),			NULL);	if (n > 0)		{		// Remove any trailing CR's or LF's since some messages have them.		while ((n > 0) && isspace(((unsigned char *) buffer)[n - 1]))			buffer[--n] = '/0';		}	return buffer;	}

void_mongoc_sspi_set_gsserror (DWORD errCode, const SEC_CHAR *msg){   SEC_CHAR *err;   DWORD status;   DWORD flags = FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |                 FORMAT_MESSAGE_IGNORE_INSERTS;   status = FormatMessageA (flags,                            NULL,                            errCode,                            MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),                            (LPTSTR) &err,                            0,                            NULL);   if (status) {      MONGOC_ERROR ("SSPI: %s: %s", msg, err);      LocalFree (err);   } else {      MONGOC_ERROR ("SSPI: %s", msg);   }}

CString CServerSocet::MyGetLastError(){	DWORD dError;	dError = GetLastError();	void* cstr;	FormatMessageA(		FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,		NULL,		dError,		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language		(LPSTR) &cstr,		0,		NULL		);	CString res((char*)cstr);	res = ReplaceLeftSymbols(res, TRUE);	LocalFree(cstr);	CString sRet;	sRet.Format(_T("ERROR/t%d %s/n"),dError,res);	return sRet;}

const char* CLibrary::GetLoadErrorDescription(){	static char szBuffer[ 512 ];#ifdef WIN32	if( FormatMessageA( 		FORMAT_MESSAGE_FROM_SYSTEM |		FORMAT_MESSAGE_IGNORE_INSERTS,		nullptr,		GetLastError(),		MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ),		szBuffer,		sizeof( szBuffer ),		nullptr ) == 0 )	{		strcpy( szBuffer, "Unknown error" );	}#else	strncpy( szBuffer, dlerror(), sizeof( szBuffer ) );	szBuffer[ sizeof( szBuffer ) - 1 ] = '/0';#endif	size_t uiLength = strlen( szBuffer );	//Strip any newlines after the message.	if( uiLength > 0 && 		szBuffer[ uiLength - 1 ] == '/n' )	{		szBuffer[ --uiLength ] = '/0';	}	//carriage returns too (Windows).	if( uiLength > 0 &&		szBuffer[ uiLength - 1 ] == '/r' )	{		szBuffer[ --uiLength ] = '/0';	}	return szBuffer;}

void CLog::Log(LOG_LEVEL level, const char *file, int line, int error, char *fmt, ...){    if(m_pLog == NULL) return; // no log file specified	if(level > m_level) return; // too detail	// format time	char strtime[128];	time_t t = time(NULL);	struct tm *tt = gmtime(&t);	snprintf(strtime, sizeof(strtime)-1, "%d-%d-%d %d:%d:%d", 1900+tt->tm_year, tt->tm_mon, 		tt->tm_yday, tt->tm_hour, tt->tm_min, tt->tm_sec);		// format message	char buf[64*1024]; // max error message size in Windows	va_list maker;	va_start(maker, fmt);	vsnprintf(buf, sizeof(buf)-1, fmt, maker);	va_end(maker);	fprintf(m_pLog, "[%s][%s][%s][line:%d]%s[errno=%d]", strtime, GetLevelString(level), file, line, buf, error);	// format error strings	buf[0] = '/0';	if(error != 0)	{#ifdef WIN32 // Windows		FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, DWORD(error), 0, buf, sizeof(buf)-1, NULL);		fprintf(m_pLog, "%s./n", buf);#else // Linux		fprintf(m_pLog, "%s./n", strerror(error));#endif	}	else	{		fprintf(m_pLog, "./n");	}	// flush file for error message	if(level == LL_ERROR)	{		fflush(m_pLog);	}}

static voiddlfailure(void){#ifdef _WIN32    LPSTR msg;    DWORD dwBufferLength;    DWORD dwLastError = GetLastError();    DWORD dwFormatFlags = FORMAT_MESSAGE_ALLOCATE_BUFFER |	    FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM;    if ((dwBufferLength = FormatMessageA(dwFormatFlags, NULL, dwLastError,		    0, (LPSTR) &msg, 0, NULL))) {	msg[dwBufferLength] = '/0';	fprintf(stderr, "Error: %s", msg);	LocalFree(msg);    }#else    fprintf(stderr, "Error: %s", dlerror());#endif	/*_WIN32*/    exit(2);}

std::string System_error::message () const{	std::string	mesg(action);	if (!target.empty()) {		mesg += ": ";		mesg += target;	}	if (error) {		LPTSTR	error_message;		FormatMessageA(			FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,			NULL,			error,			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),			reinterpret_cast<LPTSTR>(&error_message),			0,			NULL);		mesg += error_message;		LocalFree(error_message);	}	return mesg;}

static void assert_result(HRESULT hres, JNIEnv *env) {#ifdef _DEBUG    if (hres != 0) {        DWORD lastError = GetLastError();        if (lastError != 0) {            LPSTR msgBuffer = NULL;            FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |                    FORMAT_MESSAGE_FROM_SYSTEM |                    FORMAT_MESSAGE_IGNORE_INSERTS,                    NULL,                    lastError,                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),                    (LPSTR)&msgBuffer,                    // it's an output parameter when allocate buffer is used                    0,                    NULL);            DTRACE_PRINTLN3("Error: hres=0x%x lastError=0x%x %s/n", hres,                                                lastError, msgBuffer);        }    }#endif}

void PrintError( int error ){	LPSTR errorText = NULL;	FormatMessageA(	   // use system message tables to retrieve error text	   FORMAT_MESSAGE_FROM_SYSTEM	   // allocate buffer on local heap for error text	   |FORMAT_MESSAGE_ALLOCATE_BUFFER	   // Important! will fail otherwise, since we're not 	   // (and CANNOT) pass insertion parameters	   |FORMAT_MESSAGE_IGNORE_INSERTS,  	   NULL,    // unused with FORMAT_MESSAGE_FROM_SYSTEM	   error,	   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),	   (LPSTR)&errorText,  // output 	   0, // minimum size for output buffer	   NULL);   // arguments - see note	if (errorText != NULL)	{		LOG(ERR,"Error: [%d] %s", error, errorText);	}}

void glwtWin32Error(const char *msg){   LPVOID msgbuf = 0;   DWORD err = GetLastError();    if(!FormatMessageA(        FORMAT_MESSAGE_ALLOCATE_BUFFER |        FORMAT_MESSAGE_FROM_SYSTEM |        FORMAT_MESSAGE_IGNORE_INSERTS,        NULL,        err,        0,        (LPSTR) &msgbuf,        0, NULL ))    {        glwtErrorPrintf("%s: %d/n", msg, err);        return;    }    glwtErrorPrintf("%s: %s/n", msg, (const char *)msgbuf);    LocalFree(msgbuf);}

const char *_p11_module_error (void){	DWORD code = GetLastError();	p11_local *local;	LPVOID msg_buf;	local = _p11_library_get_thread_local ();	FormatMessageA (FORMAT_MESSAGE_ALLOCATE_BUFFER |	                FORMAT_MESSAGE_FROM_SYSTEM |	                FORMAT_MESSAGE_IGNORE_INSERTS,	                NULL, code,	                MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),	                (LPSTR)&msg_buf, 0, NULL);	if (local->last_error)		LocalFree (local->last_error);	local->last_error = msg_buf;	return msg_buf;}

/* Displays an error and doesn't die. */void nberror(char *str){  int error = getlasterror();#ifdef WIN32  char error_str[1024];  FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, error, 0, error_str, 1024, NULL);  if(str)    fprintf(stderr, "%s/n", str);  fprintf(stderr, "Error %d: %s", error, error_str);#else  char *error_str = strerror(error);  if(str)    fprintf(stderr, "%s (error %d: %s)/n", str, error, error_str);  else    fprintf(stderr, "Error %d: %s/n", error, error_str);#endif}