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

	void Write(const char *fmt, ...)	{#ifdef OM_TRACE_ENABLE		va_list ap;		va_start(ap, fmt);		const int SIZ = 10*1024;		char buf[SIZ];#ifdef WIN32		vsnprintf_s(buf, SIZ, SIZ, fmt, ap);#else		vsprintf(buf, fmt, ap);#endif		DebugWrite(buf);#endif	}

void IOConsole::Error(const char *formatString, ...){	va_list ap;	va_start(ap, formatString);	char buffer[MAX_STRING_LENGTH];	vsnprintf_s(buffer, MAX_STRING_LENGTH, MAX_STRING_LENGTH-1, formatString, ap);	SetConsoleTextAttribute(m_hOutput, FOREGROUND_RED | FOREGROUND_INTENSITY);	(*this) << buffer;	SetConsoleTextAttribute(m_hOutput, FOREGROUND_RED | FOREGROUND_BLUE 		| FOREGROUND_GREEN | FOREGROUND_INTENSITY);	va_end(ap);	//		assert(0);}

int MyMeshText::CreateStringColorAndShadow(bool concat, float fontheight, float x, float y, unsigned char justificationflags, ColorByte color, ColorByte shadowcolor, float shadowoffx, float shadowoffy, Vector2 size, const char* text, ...){    const char* stringtodraw = text;    if( g_pLanguageTable != 0 && text[0] == '.' )        stringtodraw = g_pLanguageTable->LookUp( text );    char* tempbuffer = g_pRTQGlobals->m_TempBuffer;    va_list arg;    va_start( arg, text );    vsnprintf_s( tempbuffer, sizeof(g_pRTQGlobals->m_TempBuffer), _TRUNCATE, stringtodraw, arg );    va_end(arg);        CreateString( concat, fontheight, x+shadowoffx, y+shadowoffy, 0, 0, justificationflags, shadowcolor, size, tempbuffer );    concat = true;    return CreateString( concat, fontheight, x, y, 0, 0, justificationflags, color, size, tempbuffer );}

void CCALL	WriteReport_Alert (const char* format, ...){	char		buffer [512];	va_list		argList;	va_start (argList, format);#if defined (macintosh)	vsnprintf (buffer, sizeof (buffer), format, argList);#else	vsnprintf_s (buffer, sizeof (buffer), _TRUNCATE, format, argList);#endif	ACAPI_WriteReport (buffer, true);	return;}		// WriteReport_Alert

CMethodLogger::CMethodLogger(const char* aFile, const char* aFunction, const std::string& aMessage, int aLine, ...) : iFile(aFile), iFunction(aFunction), iLine(aLine){   // Assemble the user-generated message   std::string msg = std::string(">> ENTRY: ") + aMessage;   char buffer[510];   va_list args;   va_start(args, aLine);#ifdef AK_SYSTEM_WINDOWS   vsnprintf_s(buffer, 500, _TRUNCATE, msg.c_str(), args);#else   vsnprintf(buffer, 500, msg.c_str(), args);#endif   va_end(args);   LogAppend(ELogLevel::EDEBUG, iFile, iFunction, buffer, iLine);}

int LOG_ALT(const char *fmt,...){	char buf[102400];	int len = sizeof(buf)-1;	int xlen = 0;    iop_log_service_t *log = g_iop_log_service;    struct tm t;	int level = IOP_LOG_ALERT;    time_t n ;	int r;	if(log && (level > log->log_level))    {        return -1;    }	buf[len] = 0;	n= time(NULL);	#ifdef WIN32		localtime_s(&t,&n);		r = _snprintf_s(buf,len, len,"[ALT %02d:%02d:%02d] ",                 t.tm_hour,t.tm_min, t.tm_sec);	#else		t = *localtime(&n);	    r = snprintf(buf,len, "[ALT %02d:%02d:%02d] ",                 t.tm_hour,t.tm_min, t.tm_sec);	#endif	{	va_list ap;    va_start(ap, fmt);#ifdef WIN32	xlen = vsnprintf_s((char *)buf+r,len-r,len-r, fmt, ap);#else	xlen = vsnprintf((char *)buf+r,len-r, fmt, ap);#endif	va_end(ap);	}    if(xlen + r > len)    {        r = len;    }    else    {        r += xlen;    }    return iop_log_write(log,buf, r);}

      static int      format(char* str, size_t size, const char* format, ...)      {        std::va_list ap;        va_start(ap, format);#if defined(DUNE_SYS_HAS_VSNPRINTF)        int rv = vsnprintf(str, size, format, ap);#elif defined(DUNE_SYS_HAS_VSNPRINTF_S)        int rv = vsnprintf_s(str, size, size - 1, format, ap);#else        int rv = std::vsprintf(str, format, ap);#endif        va_end(ap);        return rv;      }

/// @par////// Example:/// @code/// // Where ctx is an instance of rcContext and filepath is a char array./// ctx->log(RC_LOG_ERROR, "buildTiledNavigation: Could not load '%s'", filepath);/// @endcodevoid rcContext::log(const rcLogCategory category, const char* format, ...){    if (!m_logEnabled)        return;    static const int MSG_SIZE = 512;    char msg[MSG_SIZE];    va_list ap;    va_start(ap, format);    int len = vsnprintf_s(msg, MSG_SIZE, format, ap);    if (len >= MSG_SIZE)    {        len = MSG_SIZE-1;        msg[MSG_SIZE-1] = '/0';    }    va_end(ap);    doLog(category, msg, len);}

void log(const char * pszFormat, ...){    char szBuf[MAX_LEN];    va_list ap;    va_start(ap, pszFormat);    vsnprintf_s(szBuf, MAX_LEN, MAX_LEN, pszFormat, ap);    va_end(ap);    WCHAR wszBuf[MAX_LEN] = {0};    MultiByteToWideChar(CP_UTF8, 0, szBuf, -1, wszBuf, sizeof(wszBuf));    OutputDebugStringW(wszBuf);    OutputDebugStringA("/n");    WideCharToMultiByte(CP_ACP, 0, wszBuf, sizeof(wszBuf), szBuf, sizeof(szBuf), NULL, FALSE);    printf("%s/n", szBuf);}

// [v]snprintf on Windows only matches C99 when no errors or overflow.int pn_i_vsnprintf(char *buf, size_t count, const char *fmt, va_list ap) {  if (fmt == NULL)    return -1;  if ((buf == NULL) && (count > 0))    return -1;  if (count > 0) {    int n = vsnprintf_s(buf, count, _TRUNCATE, fmt, ap);    if (n >= 0)  // no overflow      return n;  // same as C99    buf[count-1] = '/0';  }  // separate call to get needed buffer size on overflow  int n = _vscprintf(fmt, ap);  if (n >= (int) count)    return n;  return -1;}

	void Trace(const char * msg, ...)	{		if( s_Enable )		{			EnterCriticalSection(&logCS);			static char buffer[BUFFER_SIZE] = {0,};			va_list args;			va_start(args, msg);			vsnprintf_s(buffer, BUFFER_SIZE, BUFFER_SIZE-1, msg, args);			va_end(args);						cout << buffer << endl;			LeaveCriticalSection(&logCS);		}	}

	////////////////////// func. /////////////////////	void JString::Format(const char* format, ...)	{		va_list vlist;		char* pTempBuf = new char[JSTRING_BUFFER_MAX + 1];		pTempBuf[0] = NULL;		va_start(vlist, format);		vsnprintf_s(pTempBuf, JSTRING_BUFFER_MAX + 1, JSTRING_BUFFER_MAX, format, vlist);		va_end(vlist);		Release();		Init(strlen(pTempBuf));		strncpy_s(pBuffer, nLength + 1, pTempBuf, nLength);		delete[] pTempBuf;	}

void log(const char* text, ...){	const int BUFFER_SIZE = 1024;	char buffer[BUFFER_SIZE];	va_list ap;	va_start(ap, text);	vsnprintf_s(buffer, BUFFER_SIZE, BUFFER_SIZE, text, ap);	va_end(ap);	FILE *outfile;	if (fopen_s(&outfile, "bwapi-data//logs//BWSAL.log", "a+")==0)	{		fprintf_s(outfile, buffer);		fclose(outfile);	}}

void NCLDebug::DrawTextWsNDT(const Vector3& pos, const float font_size, const TextAlignment alignment, const Vector4 colour, const string text, ...){	va_list args;	va_start(args, text);	char buf[1024];	int needed = vsnprintf_s(buf, 1023, _TRUNCATE, text.c_str(), args);	va_end(args);	int length = (needed < 0) ? 1024 : needed;	std::string formatted_text = std::string(buf, (size_t)length);	Vector4 cs_pos = m_ProjViewMtx * Vector4(pos.x, pos.y, pos.z, 1.0f);	cs_pos.z = 1.0f * cs_pos.w;	DrawTextCs(cs_pos, font_size, formatted_text, alignment, colour);}

void CLogFile::Printf(const char * szFormat, ...){	// Lock the mutex	m_mutex.TryLock(1);	// Collect the arguments	va_list vaArgs;	char szBuffer[2048];	va_start(vaArgs, szFormat);	vsnprintf_s(szBuffer, sizeof(szBuffer), szFormat, vaArgs);	va_end(vaArgs);	// Print the message	Print(szBuffer);	// Unlock the mutex	m_mutex.Unlock();}

int debugPrintf( const char *format, ... )	{	va_list argPtr;	char buffer[ 1024 ];	int length;	va_start( argPtr, format );#if VC_GE_2005( _MSC_VER )	length = vsnprintf_s( buffer, 1024, _TRUNCATE, format, argPtr );#else	length = vsprintf( buffer, format, argPtr );#endif /* VC++ 2005 or newer */	va_end( argPtr );	OutputDebugString( buffer );	return( length );	}

intflac_snprintf(char *str, size_t size, const char *fmt, ...){	va_list va;	int rc ;	va_start (va, fmt);#ifdef _MSC_VER	rc = vsnprintf_s (str, size, _TRUNCATE, fmt, va);	rc = (rc > 0) ? rc : (size == 0 ? 1024 : size * 2);#else	rc = vsnprintf (str, size, fmt, va);#endif	va_end (va);	return rc;}

		AssertBehavior ReportFailure(const char* condition, const char* file, int line, const char* msg, ...)		{			const char* message = nullptr;			if (msg != nullptr)			{				char messageBuffer[1024];				{					va_list args;					va_start(args, msg);					vsnprintf_s(messageBuffer, 1024, msg, args);					va_end(args);				}				message = messageBuffer;			}			return DefaultAssertHandler(condition, message, file, line);		}

void die(char * message,...){    char    buf[1024];    va_list args;    va_start(args, message);#if defined(SAFESTR)    vsnprintf_s(buf, sizeof(buf), sizeof(buf) - 1, message, args);#else    _vsnprintf(buf, sizeof(buf), message, args);#endif    fprintf(stderr, "%s/n", buf);    if (g_log)    {        g_log->Log(0, "die", buf);    }    my_exit(1);}

      static std::string      str(const char* format, ...)      {        char bfr[1024] = {0};        std::va_list ap;        va_start(ap, format);#if defined(DUNE_SYS_HAS_VSNPRINTF)        vsnprintf(bfr, sizeof(bfr), format, ap);#elif defined(DUNE_SYS_HAS_VSNPRINTF_S)        vsnprintf_s(bfr, sizeof(bfr), sizeof(bfr) - 1, format, ap);#else        std::vsprintf(bfr, format, ap);#endif        va_end(ap);        return bfr;      }

staticint local_vsnprintf(char *str, size_t size, const char *fmt, va_list va){	int rc;#if defined _MSC_VER	if (size == 0)		return 1024;	rc = vsnprintf_s (str, size, _TRUNCATE, fmt, va);	if (rc < 0)		rc = size - 1;#elif defined __MINGW32__	rc = __mingw_vsnprintf (str, size, fmt, va);#else	rc = vsnprintf (str, size, fmt, va);#endif	return rc;}

void vClient::SendSystem( char* szStr, ... ){	static const Address addrCall = 0x00494910;	char szBuff[512] = {0,};	va_list arg;	va_start(arg, szStr);	vsnprintf_s(szBuff, 512, szStr, arg);	va_end(arg);	__asm	{		lea		ecx, szBuff;		push	ecx;		mov		ecx, addrCoreClient;		call	addrCall;	}}

internalvoid writeFileLine(file_t* file, const char* format, ...){	char line[512];	va_list args;	va_start(args, format);	vsnprintf_s(line, sizeof(line), _TRUNCATE, format, args);	va_end(args);	char* write = line;	while (*write)		write++;	*(write++) = '/r';	*(write++) = '/n';	*(write++) = 0;	file_write(file, line);}

internalvoid writeFileKeyValue(file_t* file, const char* key, const char* valueFormat, ...){	char value[256];	char line[512];	va_list args;	va_start(args, valueFormat);	vsnprintf_s(value, sizeof(value), _TRUNCATE, valueFormat, args);	va_end(args);	char* write = str_append(line, key);	*(write++) = '=';	write = str_append(write, value);	*(write++) = '/r';	*(write++) = '/n';	*(write++) = 0;	file_write(file, line);}

void EbrDebugLogShim(const char* format, ...) {#ifdef _DEBUG    va_list va;    va_start(va, format);    char buf[c_bufferCount];    int len = vsnprintf_s(buf, _countof(buf), _TRUNCATE, format, va);    va_end(va);    // Trim off newline for EBR debug.    if ((len > 0) && (len < (c_bufferCount - 1)) && (buf[len - 1] == '/n')) {        buf[len - 1] = '/0';    }    wchar_t wbuf[c_bufferCount];    size_t wlen;    mbstowcs_s(&wlen, wbuf, _countof(wbuf), buf, _TRUNCATE);    TraceVerbose(L"EbrDebugLog", wbuf);#endif}

void LogError ( const char* traceStr, ... ){	va_list argsVA;	const int logSize = 4096;	char buffer[logSize];	memset ( (void*)buffer, 0, logSize );	va_start ( argsVA, traceStr );#ifdef WIN32	vsnprintf_s( buffer, logSize, logSize, traceStr, argsVA );#else	vsnprintf( buffer, logSize, traceStr, argsVA );#endif	va_end( argsVA );	LogMsg("ERROR: %s", buffer);	GetBaseApp()->SetConsoleVisible(true); //make sure we see the error	//assert(!"Got an error, your majesty...");}

sText::sText(std::string Fontfile, unsigned int size, const char *fmt, ...){	char text[1024];	va_list ap;	if(fmt == NULL) return;	va_start(ap, fmt);	vsnprintf_s(text,1024,1024, fmt, ap);	va_end(ap);	FontObject.loadFromFile(std::string("Media/").append(Fontfile));		textObject.setFont(FontObject);		textObject.setCharacterSize(size);	textObject.setString(text);}

	void write(const char* format, ...)	{		if (fh.isValidFile() == false)			return;		size_t size = 512;		char* temp = NULL;		va_list arglist;		va_start( arglist, format );		int res = 0;		do		{			size *= 2;						if (temp)				delete [] temp;			temp = new char[size];			#ifdef WIN32			res = vsnprintf_s(temp, size, _TRUNCATE, format, arglist);#else			res = vsnprintf(temp, size, format, arglist);#endif		}#ifdef WIN32		while (res == -1);#else		while ((size_t)res > size);#endif				va_end( arglist );		try		{			fh.write(temp, res);		}		catch (...)		{		}	}

//-----------------------------------------------------------------------------------------------void DebuggerPrintf( const char* messageFormat, ... ){	const int MESSAGE_MAX_LENGTH = 2048;	char messageLiteral[ MESSAGE_MAX_LENGTH ];	va_list variableArgumentList;	va_start( variableArgumentList, messageFormat );	vsnprintf_s( messageLiteral, MESSAGE_MAX_LENGTH, _TRUNCATE, messageFormat, variableArgumentList );	va_end( variableArgumentList );	messageLiteral[ MESSAGE_MAX_LENGTH - 1 ] = '/0'; // In case vsnprintf overran (doesn't auto-terminate)#if defined( PLATFORM_WINDOWS )	if( IsDebuggerAvailable() )	{		OutputDebugStringA( messageLiteral );	}#endif	std::cout << messageLiteral;}