Comment activer la macro TRACE en mode Release?

La TRACE macro peut être utilisé pour la sortie des messages de diagnostic pour le débogueur lorsque le code est compilé en Debug mode. J'ai besoin de la même messages tout en Libération mode. Est-il un moyen pour y parvenir?

(S'il vous plaît ne pas perdre votre temps à discuter de pourquoi je ne devrais pas être à l'aide de la TRACE en mode Release 🙂

source d'informationauteur Ashwin Nanjappa

8

En fait, la TRACE de la macro est beaucoup plus flexible que OutputDebugString. Il faut un "printf ()" style de format de chaîne de caractères et de la liste des paramètres alors que OutputDebugString prend juste une seule chaîne. Afin de mettre en œuvre la TRACE complète de la fonctionnalité en mode release, vous avez besoin de faire quelque chose comme ceci:
```
void trace(const char* format, ...)
{
   char buffer[1000];

   va_list argptr;
   va_start(argptr, format);
   wvsprintf(buffer, format, argptr);
   va_end(argptr);

   OutputDebugString(buffer);
}
```

Quelques années en arrière j'ai besoin de fonctionnalités similaires, donc j'ai bricolé le code suivant. Il suffit de la sauvegarder dans un fichier, par exemple rtrace.h, de l'inclure à la fin de votre stdafx.h, et ajouter _RTRACE à la version du mode de Préprocesseur.

Peut-être que quelqu'un va trouver une utilisation pour elle 🙂

Jean

#pragma fois 

//------------------------------------------------------------------------------------------------ 
//
//Auteur: John Cullen 
//Date: 2006/04/12 
//Sur la base de: MSDN exemples de listes d'arguments variable et ATL mise en œuvre de TRACE. 
//
//Description: Permet l'utilisation des instructions de suivi dans les versions RELEASE, en remplaçant les 
//TRACE la définition de macro et de la redéfinition en termes de RTRACE classe et surchargé 
opérateur //(). La sortie de Trace générée par l'appel de OutputDebugString() directement. 
//
//
//Utilisation: Ajouter à la fin de stdafx.h et ajouter _RTRACE pour le préprocesseur (généralement 
//pour les versions RELEASE, bien que le drapeau sera ignorée pour les versions de DÉBOGAGE. 
//
//------------------------------------------------------------------------------------------------ 

#ifdef _DEBUG 

//NL défini comme un raccourci pour l'écriture FTRACE(_T("\n")); par exemple, au lieu d'écrire FTRACE(NL); 
#define NL _T("\n") 
#define LTRACE TRACE(_T("%s(%d): "), __FILE__, __LINE__); TRACE 
#define FTRACE TRACE(_T("%s(%d): %s: "), __FILE__, __LINE__, __FUNCTION__); TRACE 

#else //_DEBUG 

#ifdef _RTRACE 
#undef TRACE 
#define TRACE RTRACE() 
#define LTRACE RTRACE(__FILE__, __LINE__) 
#define FTRACE RTRACE(__FILE__, __LINE__, __FUNCTION__) 
#define NL _T("\n") 

classe RTRACE 
{ 
public: 
//constructeur par défaut, aucun params 
RTRACE(void) : m_pszFileName( NULL ), m_nLineNo( 0 ), m_pszFuncName( NULL ) {}; 

//surcharge de constructeur, le nom de fichier et lineno 
RTRACE(PCTSTR const pszFileName, int nLineNo) : 
m_pszFileName(pszFileName), m_nLineNo(nLineNo), m_pszFuncName(NULL) {}; 

//surcharge de constructeur, le nom de fichier, lineno, et le nom de la fonction 
RTRACE(PCTSTR const pszFileName, int nLineNo, PCTSTR const pszFuncName) : 
m_pszFileName(pszFileName), m_nLineNo(nLineNo), m_pszFuncName(pszFuncName) {}; 

virtual ~RTRACE(void) {}; 

//pas de passage d'arguments, par exemple RTRACE()() 
void operator()() const 
{ 
//pas de passage d'arguments, juste vider le dossier, ligne et de la fonction si demandé 
OutputFileAndLine(); 
OutputFunction(); 
} 

//chaîne de format et les paramètres transmis, par exemple RTRACE()(_T("%s\n"), someStringVar) 
void operator()(const PTCHAR pszFmt, ...) const 
{ 
//vidage du fichier, la ligne et de la fonction si demandé, suivie par la TRACE des arguments 
OutputFileAndLine(); 
OutputFunction(); 

//exécution de la norme de la sortie de TRACE de traitement 
va_list ptr; va_start( ptr, pszFmt ); 
INT len = _vsctprintf( pszFmt, ptr ) + 1; 
TCHAR* buffer = (PTCHAR) malloc( l * sizeof(TCHAR) ); 
_vstprintf( tampon, pszFmt, ptr ); 
OutputDebugString(tampon); 
free( buffer ); 
} 

privé: 
//de sortie, le courant de fichier et la ligne 
inline void OutputFileAndLine() const 
{ 
si (m_pszFileName && _tcslen(m_pszFileName) > 0) 
{ 
INT len = _sctprintf( _T("%s(%d): "), m_pszFileName, m_nLineNo ) + 1; 
PTCHAR buffer = (PTCHAR) malloc( l * sizeof(TCHAR) ); 
_stprintf( tampon, _T("%s(%d): "), m_pszFileName, m_nLineNo ); 
OutputDebugString( tampon ); 
free( buffer ); 
} 
} 

//sortie de l'actuel nom de la fonction 
inline void OutputFunction() const 
{ 
si (m_pszFuncName && _tcslen(m_pszFuncName) > 0) 
{ 
INT len = _sctprintf( _T("%s: "), m_pszFuncName ) + 1; 
PTCHAR buffer = (PTCHAR) malloc( l * sizeof(TCHAR) ); 
_stprintf( tampon, _T("%s: "), m_pszFuncName ); 
OutputDebugString( tampon ); 
free( buffer ); 
} 
} 

privé: 
PCTSTR const m_pszFuncName; 
PCTSTR const m_pszFileName; 
const int m_nLineNo; 
}; 

#endif //_RTRACE 

#endif //NDEBUG

2

TRACE est juste une macro pour OutputDebugString. Donc, vous pouvez facilement faire votre propre TRACE macro (ou appeler quelque chose d'autre) qui va appeler OutputDebugString.

C'est plus simplement le code que j'ai dû voir

#undef ATLTRACE
#undef ATLTRACE2

#define ATLTRACE2 CAtlTrace(__FILE__, __LINE__, __FUNCTION__)
#define ATLTRACE ATLTRACE2

voir
http://alax.info/blog/1351

1

Dans MFC, TRACE est défini comme ATLTRACE. Et en mode release, qui est défini comme:
```
#define ATLTRACE            __noop
```
Donc, en utilisant le hors-la-boîte de TRACE de MFC, vous n'allez pas être en mesure de lire toute TRACE de texte, car il n'est pas encore écrite. Vous pouvez écrire votre propre fonction TRACE () au lieu de cela, puis re-définir la TRACE de la macro. Vous pourriez faire quelque chose comme ceci:
```
void MyTrace(const CString& text)
{
  ::OutputDebugString(text); //Outputs to console, same as regular TRACE
  //TODO: Do whatever output you need here. Write to event log /write to text file /write to pipe etc.
}
```

Vous devez vous connecter pour publier un commentaire.