`_CrtSetDbgFlag`

Článek
10/12/2023

Načte nebo upraví stav příznaku _crtDbgFlag tak, aby kontroloval chování přidělení správce haldy ladění (pouze ladicí verze).

Syntaxe

int _CrtSetDbgFlag(
   int newFlag
);

Parametry

newFlag
Nový stav pro _crtDbgFlag.

Vrácená hodnota

Vrátí předchozí stav _crtDbgFlag.

Poznámky

Funkce _CrtSetDbgFlag umožňuje aplikaci řídit, jak správce haldy ladění sleduje přidělení paměti úpravou bitových polí příznaku _crtDbgFlag . Nastavením bitových polí může aplikace instruovat správce haldy ladění, aby prováděl speciální operace ladění. Existuje několik možných operací:

Kontrola nevracení paměti při ukončení aplikace a hlášení, pokud jsou nalezeny nějaké
Simulace podmínek nedostatku paměti zadáním, že uvolněné bloky paměti by měly zůstat v propojeném seznamu haldy.
Ověření integrity haldy kontrolou každého bloku paměti při každém požadavku na přidělení.

Pokud _DEBUG není definováno, volání, která _CrtSetDbgFlag se mají odebrat během předběžného zpracování.

Následující tabulka uvádí bitová pole a _crtDbgFlag popisuje jejich chování. Vzhledem k tomu, že nastavení bitů vede ke zvýšení diagnostického výstupu a snížení rychlosti provádění programu, nejsou tyto bity ve výchozím nastavení nastavené (vypnuté). Další informace o těchto bitových polích najdete v tématu Funkce generování sestav stavu haldy.

Bitové pole	Výchozí	Popis
`_CRTDBG_ALLOC_MEM_DF`	ON	ZAPNUTO: Povolte přidělení haldy ladění a použití identifikátorů typu bloku paměti, například `_CLIENT_BLOCK`. VYPNUTO: Přidejte nové přidělení do propojeného seznamu haldy, ale nastavte typ bloku na `_IGNORE_BLOCK`. Lze také kombinovat s některou z maker kontroly haldy frekvence.
`_CRTDBG_CHECK_ALWAYS_DF`	OFF	ZAPNUTO: Volání `_CrtCheckMemory` při každém přidělení a žádosti o přidělení. VYPNUTO: `_CrtCheckMemory` Musí být volána explicitně. Makra kontroly četnosti haldy nemají žádný vliv při nastavení tohoto příznaku.
`_CRTDBG_CHECK_CRT_DF`	OFF	ZAPNUTO: Zahrňte `_CRT_BLOCK` typy do operací detekce nevracení a rozdílu stavu paměti. VYPNUTO: Tyto operace ignorují paměť používaná interně knihovnou za běhu. Lze také kombinovat s některou z maker kontroly haldy frekvence.
`_CRTDBG_DELAY_FREE_MEM_DF`	OFF	ZAPNUTO: Uchovávejte uvolněné paměťové bloky v propojeném seznamu haldy, přiřaďte je `_FREE_BLOCK` typ a vyplňte je hodnotou bajtu 0xDD. VYPNUTO: Neuchovávejte volné bloky v propojeném seznamu haldy. Lze také kombinovat s některou z maker kontroly haldy frekvence.
`_CRTDBG_LEAK_CHECK_DF`	OFF	ZAPNUTO: Proveďte automatickou kontrolu nevracení při ukončení programu voláním `_CrtDumpMemoryLeaks` a vygenerujte zprávu o chybě, pokud se aplikaci nepodařilo uvolnit veškerou přidělenou paměť. VYPNUTO: Při ukončení programu automaticky neprovádějte kontrolu úniku. Lze také kombinovat s některou z maker kontroly haldy frekvence.

Makra četnosti kontroly haldy

Můžete určit, jak často knihovna runtime jazyka C provádí ověření haldy ladění (_CrtCheckMemory) na základě počtu volání , mallocrealloc, freea _msize.

_CrtSetDbgFlag pak zkontroluje horních 16 bitů parametru newFlag pro hodnotu. Zadaná hodnota je počet mallocvolání , realloc, freea _msize volání mezi _CrtCheckMemory voláními. Pro tento účel jsou k dispozici čtyři předdefinovaná makra.

Makro	Počet `malloc`volání , `realloc`, `free`a `_msize` volání mezi voláními na `_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í bez kontrol haldy)

Ve výchozím nastavení _CrtCheckMemory se během operací paměti nevolá. Můžete to změnit odesláním příznaků zobrazených výše na _CrtSetDbgFlag().

Můžete například zadat kontrolu haldy každých 16 malloc, realloc, freea _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 frequency
    tmp = (tmp & 0x0000FFFF) | _CRTDBG_CHECK_EVERY_16_DF;

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

Horních 16 bitů parametru newFlag se při zadání ignoruje _CRTDBG_CHECK_ALWAYS_DF . V tomto případě se _CrtCheckMemory volá při každém volání malloc, realloc, free, a _msize.

newFlag je nový stav, který se má použít na hodnotu _crtDbgFlag a je kombinací hodnot pro každé bitová pole.

Změna jednoho nebo více těchto bitových polí a vytvoření nového stavu příznaku

Volání _CrtSetDbgFlag se newFlag rovná _CRTDBG_REPORT_FLAG získání aktuálního _crtDbgFlag stavu a uložení vrácené hodnoty do dočasné proměnné.
Zapněte všechny bity bitovým znakem "or" (|) dočasné proměnné s odpovídajícími maskami bitů (reprezentované v kódu aplikace konstantami manifestu).
Vypněte ostatní bity bitovým "and" (&) proměnné s bitovým "not" (~) odpovídajících bitových mask.
Volání _CrtSetDbgFlag se newFlag stejnou hodnotou uloženou v dočasné proměnné pro nastavení nového stavu pro _crtDbgFlag.

Následující kód ukazuje, jak simulovat podmínky nedostatku paměti tím, že necháte volné bloky paměti v propojeném seznamu haldy a zabráníte _CrtCheckMemory tomu, aby se volala při každém požadavku na 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ávy paměti a haldy ladění najdete v podrobnostech haldy ladění CRT.

Pokud chcete zakázat příznak s _CrtSetDbgFlag funkcí, použijte bitovou "and" (&) proměnnou s bitovou bitové masky "not" (~).

Pokud newFlag není platná hodnota, tato funkce vyvolá neplatnou obslužnou rutinu parametru, jak je popsáno v ověření parametru. Pokud je spuštění povoleno pokračovat, tato funkce nastaví errno EINVAL a vrátí předchozí stav _crtDbgFlag.

Požadavky

Rutina	Požadovaný hlavičkový soubor
`_CrtSetDbgFlag`	`<crtdbg.h>`

Další informace o kompatibilitě najdete v tématu Kompatibilita.

Knihovny

Ladění pouze verzí knihoven runtime jazyka C.

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 );
}

Viz také

Rutiny ladění
_crtDbgFlag
_CrtCheckMemory

Sdílet prostřednictvím