#include <string>

std::string GetStr1() { return "str1"; }

std::string GetStr2() { return "str2"; }

void Test( std::string S1, std::string S2, std::string S3 ) {}

int main()
{
    Test( GetStr1(), GetStr2(), "str3" );
}

__asm {int 3}

#ifdef _DEBUG
#define BREAK __asm {int 3}
#else
#define BREAK
#endif

Function: f(void), Thread: 0x388 __tmainCRTStartup

struct Personne
{
    std::string Nom;
    unsigned int Age;
};

Personne = J'ai <Age> ans, et je m'appelle <Nom>

Personne = $ADDIN(MonVisualiseur.dll, DebugPersonne)

struct Test
{
    enum FLAGS
    {
        FLAG1 = (1 << 0),
        FLAG2 = (1 << 1),
        FLAG3 = (1 << 2),
        FLAG4 = (1 << 3)
    };
};

unsigned long Flags;
unsigned char Mask; 
};

#include <windows.h>
#include <cstdio>
#include <string>
#include "Test.h"

// Voici la structure que le débogueur va passer à notre fonction, et qui permettra d'accéder
// à l'objet à afficher
struct DEBUGHELPER
{
DWORD dwVersion;

BOOL (WINAPI *ReadDebuggeeMemory)(DEBUGHELPER *pThis,
                              DWORD dwAddr,
                              DWORD nWant,
                              VOID* pWhere,
                              DWORD *nGot);

// from here only when dwVersion >= 0x20000

DWORDLONG (WINAPI *GetRealAddress)(DEBUGHELPER *pThis);

BOOL (WINAPI *ReadDebuggeeMemoryEx)(DEBUGHELPER *pThis,
                                DWORDLONG qwAddr,
                                DWORD nWant,
                                VOID* pWhere,
                                DWORD *nGot);

int (WINAPI *GetProcessorType)(DEBUGHELPER *pThis);
};

// Voici la fonction que l'on va exporter, et qui permettra
// de renvoyer un message personnalisé au débogueur
extern "C" __declspec(dllexport) HRESULT WINAPI Debug(DWORD dwAddress,
                                              DEBUGHELPER *pHelper,
                                              int nBase,
                                              BOOL bUniStrings,
                                              char *pResult,
                                              size_t max,
                                              DWORD reserved)
{
    // Première chose à faire : récupérer le contenu de l'objet à afficher
    Test Obj;
    DWORD nGot = 0;
    pHelper->ReadDebuggeeMemory(pHelper, dwAddress, sizeof(Test), &Obj, &nGot);

    // On affiche son masque sous forme binaire
    std::string Result = "Masque : ";
    for (int i = 0; i < 8; ++i)
    {
        unsigned char Byte = 1 << i;
        if (Obj.Mask & (1 << i))
            Result += "1";
        else
            Result += "0";
    }

    // On affiche ses options par leur nom
    std::string Options = "";
    if (Obj.Flags & Test::FLAG1) Options += "FLAG1, ";
    if (Obj.Flags & Test::FLAG2) Options += "FLAG2, ";
    if (Obj.Flags & Test::FLAG3) Options += "FLAG3, ";
    if (Obj.Flags & Test::FLAG4) Options += "FLAG4, ";

    if (Options == "")
        Result += " - Aucune option";
    else
        Result += " - Options : " + Options.substr(0, Options.size() - 2);

    // Enfin on recopie le résultat dans la variable prévue à cet effet
    strcpy(pResult, Result.c_str());

    return S_OK;
}

// Donne un nom au thread appelant cette fonction.
// Ce nom apparaît dans le débogueur de VC++
void SetCurrentThreadName( const char * ThreadName )
{
#ifdef _MSC_VER // spécifique VC++
    typedef struct tagTHREADNAME_INFO
    {
        DWORD dwType; // must be 0x1000
        LPCSTR szName; // pointer to name (in user addr space)
        DWORD dwThreadID; // thread ID (-1=caller thread)
        DWORD dwFlags; // reserved for future use, must be zero
    } THREADNAME_INFO;

    THREADNAME_INFO info;
    info.dwType = 0x1000;
    info.szName = ThreadName;
    info.dwThreadID = (DWORD)( -1 ); // thread courant
    info.dwFlags = 0;

    __try
    {
        ::RaiseException( 
            0x406D1388, 
            0, 
            sizeof info / sizeof(DWORD),
            (DWORD*)&info );
    }
    __except ( EXCEPTION_CONTINUE_EXECUTION )
    {
    }
#else
    (void)ThreadName; // éviter les warnings
#endif
}