¿Cómo escribir en la ventana de salida en Visual Studio?

¿Qué función debo usar para enviar texto a la ventana "Salida" en Visual Studio?

Lo intenté printf()pero no aparece.

La función OutputDebugString lo hará.

código de ejemplo

    void CClass::Output(const char* szFormat, ...)
{
    char szBuff[1024];
    va_list arg;
    va_start(arg, szFormat);
    _vsnprintf(szBuff, sizeof(szBuff), szFormat, arg);
    va_end(arg);

    OutputDebugString(szBuff);
}

Si esto es para la salida de depuración, OutputDebugString es lo que desea. Una macro útil:

#define DBOUT( s )            \
{                             \
   std::ostringstream os_;    \
   os_ << s;                   \
   OutputDebugString( os_.str().c_str() );  \
}

Esto te permite decir cosas como:

DBOUT( "The value of x is " << x );

Puede extender esto usando las macros __LINE__y __FILE__para brindar aún más información.

Para aquellos en Windows y la tierra de carácter amplio:

#include <Windows.h>
#include <iostream>
#include <sstream>

 #define DBOUT( s )            \
{                             \
   std::wostringstream os_;    \
   os_ << s;                   \
   OutputDebugStringW( os_.str().c_str() );  \
}

Utilice la OutputDebugStringfunción o la TRACEmacro (MFC) que le permite hacer un printfformato de estilo:

int x = 1;
int y = 16;
float z = 32.0;
TRACE( "This is a TRACE statement\n" );    
TRACE( "The value of x is %d\n", x );
TRACE( "x = %d and y = %d\n", x, y );
TRACE( "x = %d and y = %x and z = %f\n", x, y, z );

Consejo útil: si usa __FILE__ y __LINE__luego formatea su depuración como:

"file(line): Your output here"

luego, cuando haga clic en esa línea en la ventana de salida, Visual Studio saltará directamente a esa línea de código. Un ejemplo:

#include <Windows.h>
#include <iostream>
#include <sstream>

void DBOut(const char *file, const int line, const WCHAR *s)
{
    std::wostringstream os_;
    os_ << file << "(" << line << "): ";
    os_ << s;
    OutputDebugStringW(os_.str().c_str());
}

#define DBOUT(s)       DBOut(__FILE__, __LINE__, s)

Escribí una publicación de blog sobre esto, así que siempre supe dónde podía buscarlo: https://windowscecleaner.blogspot.co.nz/2013/04/debug-output-tricks-for-visual-studio.html

Utilice OutputDebugString en lugar de afxDump.

Ejemplo:

#define _TRACE_MAXLEN 500

#if _MSC_VER >= 1900
#define _PRINT_DEBUG_STRING(text) OutputDebugString(text)
#else // _MSC_VER >= 1900
#define _PRINT_DEBUG_STRING(text) afxDump << text
#endif // _MSC_VER >= 1900

void MyTrace(LPCTSTR sFormat, ...)
{
    TCHAR text[_TRACE_MAXLEN + 1];
    memset(text, 0, _TRACE_MAXLEN + 1);
    va_list args;
    va_start(args, sFormat);
    int n = _vsntprintf(text, _TRACE_MAXLEN, sFormat, args);
    va_end(args);
    _PRINT_DEBUG_STRING(text);
    if(n <= 0)
        _PRINT_DEBUG_STRING(_T("[...]"));
}

#define WIN32_LEAN_AND_MEAN
#include <Windows.h>

wstring outputMe = L"can" + L" concatenate\n";
OutputDebugString(outputMe.c_str());

Aunque de OutputDebugStringhecho imprime una cadena de caracteres en la consola del depurador, no es exactamente como printfcon respecto a que este último pueda formatear argumentos usando la %notación y un número variable de argumentos, algo OutputDebugStringno funciona.

Yo diría que la _RPTFNmacro, con el _CRT_WARNargumento al menos, es un mejor pretendiente en este caso: formatea la cadena principal de manera muy similar a printfescribir el resultado en la consola del depurador.

Una advertencia menor (y extraña, en mi opinión) es que requiere al menos un argumento después de la cadena de formato (el que tiene todas las %sustituciones for), una limitación printfque no sufre.

Para los casos en los que necesita una putsfuncionalidad similar, sin formato, simplemente escribiendo la cadena como está, existe su hermano _RPTF0(que ignora los argumentos que siguen a la cadena de formato, otra advertencia extraña). O OutputDebugStringpor supuesto.

Y por cierto, también hay de todo, desde _RPT1hasta _RPT5pero no los he probado. Honestamente, no entiendo por qué proporcionar tantos procedimientos que hacen esencialmente lo mismo.