_CrtSetDbgFlag

Článek
03/26/2013

Načítá nebo upravuje stav _crtDbgFlag příznak, který řídí chování přidělení haldy debug manager (pouze ladicí verze).

int _CrtSetDbgFlag( 
   int newFlag 
);

Parametry

newFlag
Nový stav pro _crtDbgFlag.

Vrácená hodnota

Vrací předchozí stav _crtDbgFlag.

Poznámky

_CrtSetDbgFlag Funkce umožňuje řídit, jak správce hald ladění sleduje přidělování paměti pomocí úpravy bitových polí z _crtDbgFlag příznak.Nastavením bitů (zapnutí) můžete aplikaci pokyn správce hald ladění k operacím speciální ladění, včetně kontroly k nevrácení paměti při ukončení aplikace a sestavy, pokud nějaké nalezne, simulace nedostatku paměti určením, že uvolněné paměti bloky by měla zůstat v propojeném seznamu do haldy a ověření integrity haldy projít každý blok paměti na každý požadavek na přidělení.Při _DEBUG není definována, zavolá na _CrtSetDbgFlag jsou odebrány při úpravě před zpracováním.

Následující tabulka uvádí pole bit pro _crtDbgFlag a popisuje jejich chování.Protože nastavení bitů výsledky v lepší diagnostické výstupu a rychlost vykonávání programu snížené, nejsou nastaveny tyto bity (vypnuté) ve výchozím nastavení.Další informace o těchto bit pole naleznete v tématu halda ladění pomocí.

Bitové pole	Výchozí	Description
_CRTDBG_ALLOC_MEM_DF	ON	DÁLE: Povolit ladění přidělení hald a využívání identifikátory typu blok paměti, jako například _CLIENT_BLOCK.OFF: Přidání nové přidělení haldy propojený seznam, ale nastavit typ na _IGNORE_BLOCK. Lze také kombinovat s žádné haldy četnost kontroly maker.
_CRTDBG_CHECK_ALWAYS_DF	OFF	NA: Volat _CrtCheckMemory na každou žádost přidělování a navracení zpět.OFF: _CrtCheckMemory musí být volán explicitně. Pokud je tento příznak nastaven, haldy četnost kontroly maker mít žádný vliv.
_CRTDBG_CHECK_CRT_DF	OFF	NA: Zahrnout _CRT_BLOCK typy v nevracení paměti a zjišťování stavu rozdíl operací.VYPNUTÍ: Paměti používá interně knihovna run-time je ignorován v těchto operací. Lze také kombinovat s žádné haldy četnost kontroly maker.
_CRTDBG_DELAY_FREE_MEM_DF	OFF	DÁLE: Zachovat uvolnění paměti bloky v haldě společnosti propojený seznam, přiřadit jim _FREE_BLOCK zadejte a vyplnit hodnoty bajtů 0xDD.VYPNUTÍ: Neuchovávejte v propojeném seznamu do haldy uvolněné bloky. Lze také kombinovat s žádné haldy četnost kontroly maker.
_CRTDBG_LEAK_CHECK_DF	OFF	DÁLE: Provést automatické únik kontrolu při ukončení programu pomocí volání _CrtDumpMemoryLeaks a generovat zprávy o chybě aplikace se nepodařilo uvolnit všechny jeho přidělené paměti.OFF: Není automaticky provede kontrolu při ukončení programu nevracení paměti. Lze také kombinovat s žádné haldy četnost kontroly maker.

Kontrola haldy frekvence makra

Můžete určit, jak často běhové knihovny C provede ověření halda ladění (_CrtCheckMemory) na základě počtu volání malloc, realloc, bez, a _msize.

_CrtSetDbgFlagpoté prohlíží horní 16 bitů newFlag parametr pro hodnotu.Zadaná hodnota je počet malloc, realloc, bez, a _msize volání mezi _CrtCheckMemory volání.Pro tento účel jsou k dispozici čtyři předdefinované makra.

Makro	Počet volání malloc, realloc, volný a _msize mezi volání _CrtCheckMemory
_CRTDBG_CHECK_EVERY_16_DF	16
_CRTDBG_CHECK_EVERY_128_DF	128
_CRTDBG_CHECK_EVERY_1024_DF	1024
_CRTDBG_CHECK_DEFAULT_DF	0 (ve výchozím nastavení žádné kontroly haldy)

Ve výchozím nastavení _CrtCheckMemory je volána po každých 1 024 časy volání malloc, realloc, bez, a _msize.

Například můžete zadat haldu kontrolovat každých 16 malloc, realloc, bez, a _msize operace s následujícím kódem:

#include <crtdbg.h>
int main( )
{
int tmp;

// Get the current bits
tmp = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);

// Clear the upper 16 bits and OR in the desired freqency
tmp = (tmp & 0x0000FFFF) | _CRTDBG_CHECK_EVERY_16_DF;

// Set the new bits
_CrtSetDbgFlag(tmp);
}

Horní 16 bitů newFlag parametr jsou ignorována, pokud je zadán _CRTDBG_CHECK_ALWAYS_DF.In this case, _CrtCheckMemory is called each time you call malloc, realloc, free, and _msize.

newFlagje nový stav vyrovnat _crtDbgFlag a je kombinací hodnot pro každé pole bit.

Chcete-li změnit jeden nebo více těchto bitových polí a vytvořte nový stav příznaku

Volání _CrtSetDbgFlag s newFlag na _CRTDBG_REPORT_FLAG získat aktuální _crtDbgFlag státu a vrácená hodnota uloží do dočasné proměnné.
Zapněte všechny bity podle OR- ing dočasnou proměnnou s odpovídající bitovou masku (představovaný v kódu aplikace manifestu konstanty).
Vypnout ostatní bity ve a- ing proměnné pomocí logické bitové Ne z příslušné bitovou masku.
Volání _CrtSetDbgFlag s newFlag rovna hodnotě uložené v dočasné proměnné, chcete-li nastavit nový stav pro _crtDbgFlag.

Následující kód ukazuje, jak simulovat paměti podmínky udržováním bloky paměti v propojeném seznamu do haldy uvolněné a zabránit _CrtCheckMemory z volána při každé žádosti o přidělení:

// Get the current state of the flag
// and store it in a temporary variable
int tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );

// Turn On (OR) - Keep freed memory blocks in the
// heap's linked list and mark them as freed
tmpFlag |= _CRTDBG_DELAY_FREE_MEM_DF;

// Turn Off (AND) - prevent _CrtCheckMemory from
// being called at every allocation request
tmpFlag &= ~_CRTDBG_CHECK_ALWAYS_DF;

// Set the new state for the flag
_CrtSetDbgFlag( tmpFlag );

Přehled Správa paměti a halda ladění naleznete v tématu Správa paměti a halda ladění.

Chcete-li zakázat příznak s _CrtSetDbgFlag funkce, měli byste a v proměnné se bitové není o maskování bitů.

Pokud newFlag není platná hodnota této funkce vyvolá obslužnou rutinu neplatný parametr, jak je popsáno v Ověření parametrů.Pokud je povoleno spuštění pokračovat, tato funkce nastaví errno na EINVAL a vrací předchozí stav _crtDbgFlag.

Požadavky

Byla zahájena rutina	Požadované záhlaví
_CrtSetDbgFlag	<crtdbg.h>

Další informace o kompatibilitě v tématu Compatibility v úvodu.

Knihovny

Ladicí verze C run-time libraries pouze.

Příklad

// crt_crtsetdflag.c
// compile with: /c -D_DEBUG /MTd -Od -Zi -W3 /link -verbose:lib /debug
/*
 * This program concentrates on allocating and freeing memory
 * blocks to test the functionality of the _crtDbgFlag flag..
 */

#include <string.h>
#include <malloc.h>
#include <crtdbg.h>

int main( )
{
        char *p1, *p2;
        int tmpDbgFlag;

        _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
        _CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR );
        /*
         * Set the debug-heap flag to keep freed blocks in the
         * heap's linked list - This will allow us to catch any
         * inadvertent use of freed memory
         */
        tmpDbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
        tmpDbgFlag |= _CRTDBG_DELAY_FREE_MEM_DF;
        tmpDbgFlag |= _CRTDBG_LEAK_CHECK_DF;
        _CrtSetDbgFlag(tmpDbgFlag);

        /*
         * Allocate 2 memory blocks and store a string in each
         */
        p1 = malloc( 34 );
        p2 = malloc( 38 );
        strcpy_s( p1, 34, "p1 points to a Normal allocation block" );
        strcpy_s( p2, 38, "p2 points to a Client allocation block" );

        /*
         * Free both memory blocks
         */
        free( p2 );
        free( p1 );

        /*
         * Set the debug-heap flag to no longer keep freed blocks in the
         * heap's linked list and turn on Debug type allocations (CLIENT)
         */
        tmpDbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
        tmpDbgFlag |= _CRTDBG_ALLOC_MEM_DF;
        tmpDbgFlag &= ~_CRTDBG_DELAY_FREE_MEM_DF;
        _CrtSetDbgFlag(tmpDbgFlag);

        /*
         * Explicitly call _malloc_dbg to obtain the filename and 
         * line number of our allocation request and also so we can 
         * allocate CLIENT type blocks specifically for tracking
         */
        p1 = _malloc_dbg( 40, _NORMAL_BLOCK, __FILE__, __LINE__ );
        p2 = _malloc_dbg( 40, _CLIENT_BLOCK, __FILE__, __LINE__ );
        strcpy_s( p1, 40, "p1 points to a Normal allocation block" );
        strcpy_s( p2, 40, "p2 points to a Client allocation block" );

        /*
         * _free_dbg must be called to free the CLIENT block
         */
        _free_dbg( p2, _CLIENT_BLOCK );
        free( p1 );

        /*
         * Allocate p1 again and then exit - this will leave unfreed
         * memory on the heap
         */
        p1 = malloc( 10 );
}