Comment écrire dans la fenêtre de Sortie de Visual Studio?

Quelle fonction dois-je utiliser pour la sortie du texte à la "Sortie" de la fenêtre de Visual Studio?

J'ai essayé printf() mais il n'apparaît pas.

InformationsquelleAutor clamp | 2009-07-19

77

OutputDebugString de la fonction le fera.

exemple de code
```
    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);
}
```
- Il y a toujours un problème avec cette. _vsnprintf peut tronquer la chaîne mise en forme pour s'adapter à la mémoire tampon, mais si cela arrive, la chaîne ne sera pas nul terminée. Voir msdn.microsoft.com/en-us/library/1kt27hek.aspx et stackoverflow.com/questions/357068.
- j'obtiens une erreur, szBuff est incapable de type LPCWSTR
- Vous utilisez le jeu de caractères multioctets dans vos options de compilation. Vous devez utiliser le multi-octets versions de WCHAR szBuff[1024] _vsnwprintf
- Avertissement 1 avertissement C4996: '_vsnwprintf': Cette fonction ou une variable peut être dangereux. Pensez à utiliser _vsnwprintf_s à la place. 😉
- Ai-je besoin de #inclure quelque chose pour obtenir OutputDebugString de travail?
- inclure Windows.h
InformationsquelleAutor Sorantis
72

Si c'est pour la sortie de débogage puis OutputDebugString est ce que vous voulez. Utile en macro :
```
#define DBOUT( s )            \
{                             \
   std::ostringstream os_;    \
   os_ << s;                   \
   OutputDebugString( os_.str().c_str() );  \
}
```
Ceci permet de dire des choses comme:
```
DBOUT( "The value of x is " << x );
```
Vous pouvez l'étendre à l'aide de la __LINE__ et __FILE__ macros pour donner encore plus d'informations.

Pour ceux de Windows et le caractère large de terre:
```
#include <Windows.h>
#include <iostream>
#include <sstream>

 #define DBOUT( s )            \
{                             \
   std::wostringstream os_;    \
   os_ << s;                   \
   OutputDebugStringW( os_.str().c_str() );  \
}
```
- Pouvez-vous expliquer cette déclaration un peu? - "Vous pouvez l'étendre à l'aide de la LIGNE: et FICHIER macros pour donner encore plus d'informations."
- ces deux macros sont définies par le compilateur à l' (surprise) en ligne et fichier, de sorte que vous pouvez produire plus utile journaux contenant de la ligne et le fichier automatiquement.
- Meilleure solution de l'OMI, je vous remercie.
InformationsquelleAutor
18

Utiliser le OutputDebugString fonction ou de la TRACE macro (MFC) qui permet de faire printf-mise en forme du style:
```
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 );
```
- Voir aussi ATLTRACE2
- Mon compilateur de Visual Studio n'est pas reconnaissant ALTTRACE2 ou ALTTRACE. Ai-je besoin de #inclure quelque chose? Est-ce parce que ce n'est pas un projet MFC? C'est juste du c++ pour moi.
InformationsquelleAutor Reunanen
3

Astuce utile - si vous utilisez __FILE__ et __LINE__, puis le format de votre debug:
```
"file(line): Your output here"
```
ensuite, lorsque vous cliquez sur cette ligne dans la fenêtre de sortie de Visual Studio va sauter directement à cette ligne de code. Un exemple:
```
#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)
```
J'ai écrit un billet de blog sur ce que je savais toujours où je pourrais le regarder:
https://windowscecleaner.blogspot.co.nz/2013/04/debug-output-tricks-for-visual-studio.html

InformationsquelleAutor parsley72

Utilisation OutputDebugString au lieu de afxDump.

Exemple:

#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("[...]"));
}

InformationsquelleAutor Maurizio TALPO

0

Même si OutputDebugString en effet imprime une chaîne de caractères dans la console du débogueur, ce n'est pas exactement comme printf à l'égard de ces derniers étant capables de format arguments à l'aide de la % notation et un nombre variable d'arguments, quelque chose OutputDebugString ne pas le faire.

Je voudrais faire le cas que le _RPTFN macro, avec _CRT_WARN argument au moins, est un meilleur prétendant dans ce cas, il met en forme la principale chaîne comme printf, écrit le résultat de débogueur console.

Un mineur (et étrange, à mon avis) de mise en garde avec elle, c'est qu'il ne nécessite au moins un argument à la suite de la chaîne de format (celui avec tous les % de substitution), une limitation printf ne pas souffrent.

Pour les cas où vous avez besoin d'un puts comme fonctionnalité: pas de formatage, juste l'écriture de la chaîne en tant que-est -- il est son frère _RPTF0 (qui ignore les arguments suivant la chaîne de format, un autre étrange mise en garde). Ou OutputDebugString de cours.

Et par la manière, il y a aussi tout de _RPT1 à _RPT5 mais je n'ai pas essayé. Honnêtement, je ne comprends pas pourquoi offrira autant de procédures qui font essentiellement la même chose.

InformationsquelleAutor amn

-1

#define WIN32_LEAN_AND_MEAN
#include <Windows.h>

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

pas de travail wstring undefined
#include <string>

InformationsquelleAutor Andrew

Vous devez vous connecter pour publier un commentaire.