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

static void cvt_wprintf(FILE *dest,const wchar *fmt,va_list arglist){  // This buffer is for format string only, not for entire output,  // so it can be short enough.  wchar fmtw[1024];  PrintfPrepareFmt(fmt,fmtw,ASIZE(fmtw));#ifdef _WIN_ALL  safebuf wchar Msg[MaxMsgSize];  if (dest==stdout && StdoutRedirected || dest==stderr && StderrRedirected)  {    // Avoid Unicode for redirect in Windows, it does not work with pipes.    vswprintf(Msg,ASIZE(Msg),fmtw,arglist);    safebuf char MsgA[MaxMsgSize];    WideToChar(Msg,MsgA,ASIZE(MsgA));    CharToOemA(MsgA,MsgA); // Console tools like 'more' expect OEM encoding.    // We already converted /n to /r/n above, so we use WriteFile instead    // of C library to avoid unnecessary additional conversion.    HANDLE hOut=GetStdHandle(dest==stdout ? STD_OUTPUT_HANDLE:STD_ERROR_HANDLE);    DWORD Written;    WriteFile(hOut,MsgA,(DWORD)strlen(MsgA),&Written,NULL);    return;  }  // MSVC2008 vfwprintf writes every character to console separately  // and it is too slow. We use direct WriteConsole call instead.  vswprintf(Msg,ASIZE(Msg),fmtw,arglist);  HANDLE hOut=GetStdHandle(dest==stderr ? STD_ERROR_HANDLE:STD_OUTPUT_HANDLE);  DWORD Written;  WriteConsole(hOut,Msg,(DWORD)wcslen(Msg),&Written,NULL);#else  vfwprintf(dest,fmtw,arglist);  // We do not use setbuf(NULL) in Unix (see comments in InitConsole).  fflush(dest);#endif}

int ivsprintf(ichar *buffer, size_t max_size, const ichar *format, va_list argptr){#ifdef UNICODE__ICHAR_WIDE#ifdef _INC_SWPRINTF_INL_	return  vswprintf(buffer, max_size, format, argptr);#else	return  vswprintf(buffer, format, argptr);#endif#else	return  vsprintf(buffer, format, argptr);#endif	}

const char16 * FormatVL(const char16 * text, va_list ll){	if (formatString16Position + FORMAT_STRING_MAX_LEN >= FORMAT_STRING_SIZE)	{		formatString16Position = 0;	}#if defined(_WIN32)	int32 len = vswprintf((wchar_t *)&formatString16[formatString16Position], (wchar_t *)text, ll);#else // MAC_OS & other nix systems	int32 len = vswprintf((wchar_t *)&formatString16[formatString16Position], FORMAT_STRING_MAX_LEN, (wchar_t *)text, ll);#endif		formatString16Position += (len + 1);	return &formatString16[formatString16Position - (len + 1)];}

void_testfmt(const char *result, int line, const char *argstr, const char *fmt,...){#define	BUF	100	wchar_t ws[BUF], wfmt[BUF], wresult[BUF];	char s[BUF];	va_list ap, ap2;	va_start(ap, fmt);	va_copy(ap2, ap);	smash_stack();	vsnprintf(s, sizeof(s), fmt, ap);	if (strcmp(result, s) != 0) {		fprintf(stderr,		    "%d: printf(/"%s/", %s) ==> [%s], expected [%s]/n",		    line, fmt, argstr, s, result);		abort();	}	smash_stack();	mbstowcs(ws, s, BUF - 1);	mbstowcs(wfmt, fmt, BUF - 1);	mbstowcs(wresult, result, BUF - 1);	vswprintf(ws, sizeof(ws) / sizeof(ws[0]), wfmt, ap2);	if (wcscmp(wresult, ws) != 0) {		fprintf(stderr,		    "%d: wprintf(/"%ls/", %s) ==> [%ls], expected [%ls]/n",		    line, wfmt, argstr, ws, wresult);		abort();	}	}

voidLog(const wchar_t *fmt, ...){#if !defined(SHOW_CONSOLE)  return;#endif  va_list a = nullptr;  wchar_t szDebugString[1024];  if(!lstrlenW(fmt))    return;  va_start(a,fmt);  vswprintf(szDebugString, 1024, fmt, a);  va_end(a);  if(!lstrlenW(szDebugString))    return;  DWORD len;  WriteConsoleW(sCon, szDebugString, lstrlenW(szDebugString), &len, nullptr);  WriteConsoleW(sCon, L"/n", 1, &len, nullptr);  if (IsDebuggerPresent()) {      OutputDebugStringW(szDebugString);    OutputDebugStringW(L"/n");  }}

	void Log::PushLog( ELogType::Type type, const CHAR *pError, ... )	{		if ( type > m_logLevel )			return;		CHAR *tempMsg;		SIZE_T len = 0;		va_list arg_ptr;		va_start( arg_ptr, pError );		#if defined(PSX_UNICODE)				len = _vscwprintf( pError, arg_ptr );				tempMsg = new CHAR[len + 1];				vswprintf( tempMsg, pError, arg_ptr );		#else				len = _vscprintf( pError, arg_ptr );				tempMsg = new CHAR[len + 1];				vsprintf( tempMsg, pError, arg_ptr );		#endif /* defined(PSX_UNICODE) */		// Display in output window		OutputDebugString( tempMsg );		OutputDebugString( PSX_String("/n") );		PSX_SafeDeleteArray( tempMsg );	}

void reportx(char *msg, int etype, ...){	letter          mbuffer[4096];	letter          msgbuffer[256];	va_list         vlist;	COPYDATASTRUCT  cd;	if(!reporting_initialized) return;	if(!reporting_window) return;	if(!IsWindow(reporting_window))	{		reporting_window = 0;		return;	}	va_start(vlist, etype);	MultiByteToWideChar(CP_ACP, 0, msg, -1, msgbuffer, sizeof(msgbuffer) / sizeof(letter));	vswprintf(mbuffer, sizeof(mbuffer) / sizeof(letter), msgbuffer, vlist);	cd.cbData = sizeof(mbuffer);	cd.dwData = etype;	cd.lpData = mbuffer;	SendMessage(reporting_window, WM_COPYDATA, sizeof(letter) /* Unicode */, (LPARAM)&cd);	va_end(vlist);}

void Logger::Logv(eLogLevel ll, const char16* text, va_list li){	wchar_t tmp[4096] = {0};	vswprintf(tmp, sizeof(tmp)/sizeof(wchar_t) - 2, text, li);	wcscat(tmp, L"/n");	// always send log to custom subscribers	CustomLog(ll, tmp);	// print platform log or write log to file	// only if log level is acceptable	if (ll >= logLevel)	{        if(consoleModeEnabled)        {            ConsoleLog(ll, tmp);        }        else        {            PlatformLog(ll, tmp);        }		if(!logFilename.IsEmpty())		{			FileLog(ll, tmp);		}	}}

I32 IFXAPI IFXDebugTraceGeneric( const IFXCHAR* pFormatString, ... ){#ifndef HAS_NO_WPRINT	if ( gs_debugLevel >= IFXDEBUG_MESSAGE )	{		const IFXCHAR  *pComponentString = 			_GetStringFromIFXRESULT_Component( IFXRESULT_COMPONENT_GENERIC );		IFXCHAR pMessage[ _MESSAGE_LENGTH_MAX ];		wcscpy( pMessage, _PREFIX_STRING );		if( pComponentString )			wcscat( pMessage, pComponentString );		wcscat( pMessage, L" " );		swprintf( gs_pDebugMessage, _MESSAGE_LENGTH_MAX, pMessage );		IFXOSOutputDebugString( gs_pDebugMessage );		va_list args;		va_start( args, pFormatString );		vswprintf( gs_pDebugMessage, _MESSAGE_LENGTH_MAX,			pFormatString, args );		va_end( args );		IFXOSOutputDebugString( gs_pDebugMessage );	}#endif	return 0;}

int swprintf(wchar_t* wcs, size_t maxlen, const wchar_t* format, ...) {  va_list ap;  va_start(ap, format);  int result = vswprintf(wcs, maxlen, format, ap);  va_end(ap);  return result;}

_WCRTLINK int swprintf( CHAR_TYPE *dest, size_t n, const CHAR_TYPE *format, ... ){    va_list         args;    va_start( args, format );    return( vswprintf( dest, n, format, args ) );}

void DisplayLoadProgress(const wchar_t *format, ...){#if 0  va_list args;  wchar_t wbuf[INFO_BUF];  char buf[INFO_BUF];  /* process input */  va_start(args, format);  vswprintf(wbuf, format, args);  va_end(args);  /* XXX: convert to multibyte */  wcstombs(buf, wbuf, INFO_BUF);  printf(buf);#else  static unsigned int i = 0;  i++;  if (i == 1) printf("/b-");  else if (i == 2) printf("/b//");  else if (i == 3) printf("/b|");  else {    printf("/b/");    i = 0;  }#endif}

// Somewhat brute force, but works.  Rewrite if necessary for speed.IFXString& IFXString::VSPrintf(const IFXCHAR* fmt, va_list ap){	int sz = m_BufferLength;	if(!m_BufferLength)	{ // start at 80 bytes, seems reasonable (1 tty line)		NewBuffer(80);		sz = m_BufferLength;	}	else	{		NewBuffer(sz);	}	while(IFX_TRUE)	{		int n =  vswprintf((IFXCHAR*)m_Buffer, m_BufferLength, fmt, ap);		if(n > -1 && n < sz)		{			break;		}		if(n > -1)		{			sz = n+1;		}		else		{			sz *= 2;		}		NewBuffer(sz);	}	return *this;}

static BOOL DebugMessageV(DWORD dwSize, LPCWSTR lpszMessage, va_list arglist){    LPWSTR     lpszMsgBuf;    // Parameter checking.    if( (NULL == lpszMessage)        ||        (0 == dwSize)      )    {      return FALSE;    }    // Allocate memory for message buffer.    lpszMsgBuf = new WCHAR[dwSize + 1];        if(NULL == lpszMsgBuf)        return FALSE;    // Pass the variable parameters to wvsprintf to be formated.    vswprintf(lpszMsgBuf, lpszMessage, arglist);    // Dump string to debug output.    OutputDebugStringW(lpszMsgBuf);    // Clean up.    delete[] lpszMsgBuf;    return TRUE;}

int OS_Print(BOOL cond, const char* string, ...){	WCHAR message[OS_BUFFER_SIZE];	WCHAR wstring[OS_BUFFER_SIZE];	va_list ptr;	int iRequiredSize = 0;		if (!cond) 		return 0;	// Find out required string size (if you don't have that info)	iRequiredSize = ::MultiByteToWideChar(CP_ACP, NULL, string, -1, NULL, 0);	if (iRequiredSize > OS_BUFFER_SIZE)		iRequiredSize = OS_BUFFER_SIZE;	// Do the string conversion	::MultiByteToWideChar(CP_ACP, NULL, string , -1, wstring, iRequiredSize);        va_start(ptr,string);	vswprintf(message, wstring, ptr);    va_end(ptr);	RETAILMSG(1, (message));	return 1;}

wchar_t *dup_wprintf (int *rlen, wchar_t *format, ...){  va_list argptr;  wchar_t *result = NULL;  int len = 0;  if (format == NULL)    return NULL;  va_start(argptr, format);  len = _vscwprintf (format, argptr);  if (len >= 0)  {    result = (wchar_t *) malloc (sizeof (wchar_t *) * (len + 1));    if (result != NULL)    {      int len2 = vswprintf (result, format, argptr);      if (len2 != len || len2 <= 0)      {        free (result);        result = NULL;      }      else if (rlen != NULL)        *rlen = len;    }  }  va_end(argptr);  return result;}

int Log(LPCTSTR pszFormat, ...){	va_list ptr;	va_start(ptr, pszFormat);	wchar_t pszBuffer[1024];#pragma warning (push)#pragma warning(disable : 4995)#pragma warning(disable : 4996)	vswprintf( pszBuffer, 1024, pszFormat, ptr );#pragma warning (pop)	va_end(ptr);	theApp.PrintfToString(pszBuffer);	CCodeTesterDlg* pDlg= (CCodeTesterDlg*)theApp.GetMainWnd();	if(pDlg)	{		theApp.m_CritSection.Lock();		pDlg->m_OutPutCtrl.OutPut(pszBuffer);		theApp.m_CritSection.Unlock();		return wcslen(pszBuffer);	}	return 0;}

static void_testfmt(const char *result, const char *argstr, const char *fmt,...){#define	BUF	100	wchar_t ws[BUF], wfmt[BUF], wresult[BUF];	char s[BUF];	va_list ap, ap2;	va_start(ap, fmt);	va_copy(ap2, ap);	smash_stack();	vsnprintf(s, sizeof(s), fmt, ap);	ATF_CHECK_MSG(strcmp(result, s) == 0,	    "printf(/"%s/", %s) ==> [%s], expected [%s]",	    fmt, argstr, s, result);	smash_stack();	mbstowcs(ws, s, BUF - 1);	mbstowcs(wfmt, fmt, BUF - 1);	mbstowcs(wresult, result, BUF - 1);	vswprintf(ws, sizeof(ws) / sizeof(ws[0]), wfmt, ap2);	ATF_CHECK_MSG(wcscmp(wresult, ws) == 0,	    "wprintf(/"%ls/", %s) ==> [%ls], expected [%ls]",	    wfmt, argstr, ws, wresult);	va_end(ap);	va_end(ap2);}

int swprintf(wchar_t* s, size_t n, const wchar_t* format, ...) {  va_list args;  va_start(args, format);  int result = vswprintf(s, n, format, args);  va_end(args);  return result;}

void trace_fmt2(const char *fmt, ...) {    BOOL	en;    va_list	ap;    OEMCHAR	buf[0x1000];    en = (tracewin.en & 2) &&         ((tracewin.en & 4) || (tracewin.tf != NULL));    if (en) {        va_start(ap, fmt);#if defined(OSLANG_UCS2)        OEMCHAR cnvfmt[0x800];        MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, fmt, -1,                            cnvfmt, NELEMENTS(cnvfmt));        vswprintf(buf, cnvfmt, ap);#else        vsprintf(buf, fmt, ap);#endif        va_end(ap);        if ((tracewin.en & 4) && (hView)) {            View_AddString(buf);        }        if (tracewin.tf != FILEH_INVALID) {            textfile_write(tracewin.tf, buf);            textfile_write(tracewin.tf, crlf);        }    }}

inline VOID CharTraits<WCHAR>::FormatV( WCHAR* Buffer, SIZE_T Count, CONST WCHAR* Format, va_list Args ){  va_list Args0;  va_copy(Args0,Args);  vswprintf( Buffer, Count, Format, Args0 );  va_end(Args0);}

void GUI_Laftfont::printgl(int x, int y, int z, const wchar_t *fmt, ...){	wchar_t			text[2048];	va_list			ap;	size_t			str_len;	if ((!listsFont) || (!fmt)) return;	va_start(ap, fmt);	#ifdef WIN32		_vsnwprintf(text, 2048, fmt, ap);	#else		vswprintf(text, 2048, fmt, ap);	#endif	va_end(ap);	str_len = wcslen(text);	// should be in modelview mode	glPushMatrix();	glLoadIdentity();	glEnable(GL_TEXTURE_2D);	glListBase(listsFont);	glTranslatef((float)x, (float)y, (float)z);	glScalef(1.0f, -1.0f, 1.0f);	#ifdef WIN32		glCallLists((GLsizei)(str_len), GL_UNSIGNED_SHORT, text);	#else		glCallLists((GLsizei)(str_len), GL_UNSIGNED_INT, text);	#endif	glDisable(GL_TEXTURE_2D);	glPopMatrix();	return;}

const wchar_t* va(const wchar_t* string, ...){	static __thread int currentBuffer;	static __thread wchar_t* buffer;	if (!buffer)	{		buffer = new wchar_t[BUFFER_COUNT * BUFFER_LENGTH];	}	int thisBuffer = currentBuffer;	va_list ap;	va_start(ap, string);	int length = vswprintf(&buffer[thisBuffer * BUFFER_LENGTH], BUFFER_LENGTH, string, ap);	va_end(ap);	if (length >= BUFFER_LENGTH)	{		Com_Printf(0, "ERROR: Attempted to overrun string in call to va()!");		exit(1);	}	buffer[(thisBuffer * BUFFER_LENGTH) + BUFFER_LENGTH - 1] = '/0';	currentBuffer = (currentBuffer + 1) % BUFFER_COUNT;	return &buffer[thisBuffer * BUFFER_LENGTH];}

 int wchar_traits::Format( wchar_t** ppszDst, const wchar_t* pszFormat, va_list args ) {   int len = _vscwprintf( pszFormat, args ); // _vscprintf doesn't count terminating '/0'   *ppszDst = (wchar_t*)cui::CuiMalloc((len+1)*sizeof(wchar_t));   vswprintf(*ppszDst, pszFormat, args);   return len; }

// Note: I could overload LogMsg to take a WCHAR* as the first argument but//       this way I am less likely to match the WCHAR* version with a char* argument//       or vice versa.  It would also conflict with the UNICODE build.// Function name	: LogWMsg// Description	    : // Return type		: void // Argument         : WCHAR* pFormat// Argument         : ...void LogWMsg(WCHAR* pFormat, ...){    WCHAR    wchMsg[LOCAL_BUFFER_SIZE];    va_list pArg;    va_start(pArg, pFormat);    vswprintf(wchMsg, pFormat, pArg);    va_end(pArg);	//*	openlog("MPILauncher", LOG_APP);	char msg[LOCAL_BUFFER_SIZE];	wcstombs(msg, wchMsg, wcslen(wchMsg)+1);	syslog(LOG_INFO, msg);	closelog();	/*/	WaitForSingleObject(g_hLogMutex, INFINITE);	FILE *fout = _tfopen(MPIJOB_LOG_FILENAME, TEXT("a"));	if (fout != NULL)	{		fprintf(fout, "%4d :%7u ", GetCurrentThreadId(), clock());		fwprintf(fout, L"%s", wchMsg);		fclose(fout);	}	ReleaseMutex(g_hLogMutex);	//*/}

/*-----------------------------------------------------------------------------*/std::wstring StringUtil::Format(const wchar_t* fmt, ...){	va_list     arguments;	std::wstring buffer = L"";	assert(fmt);	va_start(arguments, fmt);	{		int length = _vscwprintf(fmt, arguments);		if (length >= 0)		{			std::unique_ptr<wchar_t[]> buf(new wchar_t[length + 1]);#ifdef _WIN32			int result = vswprintf_s(buf.get(), length + 1, fmt, arguments);#else			int result = vswprintf(buf.get(), length + 1, fmt, arguments);#endif			if (result >= 0)			{				buffer = buf.get();			}		}	}	va_end(arguments);	return buffer;}

voidLog(const wchar_t *fmt, ...){#if !defined(SHOW_CONSOLE)  DWORD dwRes = 0;  if (!GetDWORDRegKey(cehDumpDebugStrings, dwRes) || !dwRes) {    return;  }#endif  va_list a = nullptr;  wchar_t szDebugString[1024];  if(!lstrlenW(fmt))    return;  va_start(a,fmt);  vswprintf(szDebugString, 1024, fmt, a);  va_end(a);  if(!lstrlenW(szDebugString))    return;  DWORD len;  WriteConsoleW(sCon, szDebugString, lstrlenW(szDebugString), &len, nullptr);  WriteConsoleW(sCon, L"/n", 1, &len, nullptr);  OutputDebugStringW(szDebugString);  OutputDebugStringW(L"/n");}

void reportu(string msg, int etype, ...){	letter          mbuffer[4096];	va_list         vlist;	COPYDATASTRUCT  cd;	if(!reporting_initialized) return;	if(!reporting_window) return;	if(!IsWindow(reporting_window))	{		reporting_window = 0;		return;	}	va_start(vlist, etype);	vswprintf(mbuffer, sizeof(mbuffer) / sizeof(letter), msg, vlist);	cd.cbData = sizeof(mbuffer);	cd.dwData = etype;	cd.lpData = mbuffer;	SendMessage(reporting_window, WM_COPYDATA, sizeof(letter) /* Unicode */, (LPARAM)&cd);	va_end(vlist);}

int send_msg (int id, int mode, int partner, wchar_t *format, ...) {	struct message msg;	struct msqid_ds msgstat;	va_list arglist;	va_start(arglist,format);	msg.prio = partner;	vswprintf(msg.text, MSGLEN, format, arglist);	if (mode == IPC_NOWAIT) {		msgsnd(id, &msg, MSGLEN, mode);//		wprintf (L"SEND -- free: %d / self: %d / partner: %d/n", 16 - msgstat.msg_qnum, getpid(), partner);	}/*ushort msg_cbytes;    // Anzahl belegten Bytes in Queueushort msg_qnum;      // Anzahl der Nachrichten in Queueushort msg_qbytes;    // Max. Anzahl Bytes der Queue*/	else {		while (1) {			msgctl(id, IPC_STAT, &msgstat);			if ((((msgstat.msg_qbytes - msgstat.msg_cbytes) * 100) / msgstat.msg_qbytes) > QRESERVE) {//				wprintf (L"SEND -- free: %d / self: %d / partner: %d/n", 16 - msgstat.msg_qnum, getpid(), partner);				msgsnd(id, &msg, MSGLEN, mode);				break;			}//			else wprintf(L"HOLD -- free: %d / self: %d / partner: %d/n", 16 - msgstat.msg_qnum, getpid(), partner);			usleep (FREQUENCY);		}	}	return 0;}