_CrtSetDbgFlag

Artykuł
03/26/2013

Pobiera lub modyfikuje stan _crtDbgFlag flagi, aby kontrolować zachowanie alokacji Menedżer sterty debugowania (tylko wersja debugowania).

int _CrtSetDbgFlag( 
   int newFlag 
);

Parametry

newFlag
Nowy stan dla _crtDbgFlag.

Wartość zwracana

Zwraca poprzedni stan _crtDbgFlag.

Uwagi

_CrtSetDbgFlag Dzięki funkcji aplikacji do kontrolowania, jak Menedżer sterty debugowania śledzi alokacji pamięci przez zmodyfikowanie pól bitowych z _crtDbgFlag flagi.Ustawiając bitów (włączając), aplikacja może stanowić instrukcję debugowania Menedżer sterty do wykonywania specjalnych operacji debugowania, w tym sprawdzanie przecieki pamięci, kiedy kończy pracę aplikacji i raportowania, jeśli je znajdzie, symulując ilość pamięci jest mała, określając, że bloki zwolnionej pamięci powinny pozostać w połączonej listy sterty i sprawdzania integralności sterty, sprawdzając, czy każdy blok pamięci na każde żądanie alokacji.Gdy _DEBUG nie jest zdefiniowana, wzywa do _CrtSetDbgFlag są usuwane w czasie wstępnego przetwarzania.

W poniższej tabeli przedstawiono pola bitowa dla _crtDbgFlag i opisuje ich zachowanie.Ponieważ ustawienie powoduje bitów, zwiększona produkcja diagnostyczne i prędkość wykonywania programu obniżonych, bity te nie są ustalane (wyłączona) domyślnie.Aby uzyskać więcej informacji o tych bit pól, zobacz za pomocą debugowania sterty.

Pole bitowe	Domyślne	Opis
_CRTDBG_ALLOC_MEM_DF	ON	ON: Włączanie debugowania przydziałów i stosowania identyfikatorów typu blok pamięci, takich jak _CLIENT_BLOCK.OFF: Dodawanie nowych przydziałów do połączonej listy heap, ale ustawiony typ, aby zablokować _IGNORE_BLOCK. Mogą być również połączone z żadnym z makra wyboru częstotliwości sterty.
_CRTDBG_CHECK_ALWAYS_DF	OFF	ON: Wywołać _CrtCheckMemory na każde żądanie alokacji i dezalokacji.OFF: _CrtCheckMemory musi zostać wywołany jawnie. Makra wyboru częstotliwości sterty nie mają wpływu tej flagi.
_CRTDBG_CHECK_CRT_DF	OFF	ON: Obejmuje _CRT_BLOCK typów w stanie wykrywania i pamięci przecieków różnica operacji.OFF: Pamięci używane wewnętrznie przez biblioteki uruchomieniowej jest ignorowany przez te operacje. Mogą być również połączone z żadnym z makra wyboru częstotliwości sterty.
_CRTDBG_DELAY_FREE_MEM_DF	OFF	ON: Zachowaj zwolnionej pamięci, w bloki na stercie jest połączone z listy, przypisz je _FREE_BLOCK wpisz i wypełnić je bajt 0xDD.OFF: Nie jest przechowywana zwolnionej bloków w stercie połączonej listy. Mogą być również połączone z żadnym z makra wyboru częstotliwości sterty.
_CRTDBG_LEAK_CHECK_DF	OFF	ON: Wykonywanie automatycznej HERMETYCZNOŚĆ przy zamykaniu programu poprzez wywołanie _CrtDumpMemoryLeaks i wygenerować raport o błędach, jeśli aplikacja nie może zwolnić cała pamięć przydzielona go.OFF: Nie należy automatycznie wykonywać HERMETYCZNOŚĆ w momencie zamykania programu. Mogą być również połączone z żadnym z makra wyboru częstotliwości sterty.

Sprawdzanie sterty częstotliwości makra

Można określić, jak często biblioteki uruchomieniowej C sprawdza poprawność sterty debugowania (_CrtCheckMemory) na podstawie liczby połączeń w celu malloc, realloc, wolnego, i _msize.

_CrtSetDbgFlaggórny 16 bitów, a następnie sprawdza newFlag parametr dla wartości.Określona wartość jest liczbą malloc, realloc, wolnego, i _msize wywołuje między _CrtCheckMemory wywołań.Cztery wstępnie zdefiniowane makra służą do tego celu.

Makro	Liczba wywołań funkcji malloc, realloc, wolne i _msize między wywołaniami do _CrtCheckMemory
_CRTDBG_CHECK_EVERY_16_DF	16
_CRTDBG_CHECK_EVERY_128_DF	128
_CRTDBG_CHECK_EVERY_1024_DF	1024
_CRTDBG_CHECK_DEFAULT_DF	0 (domyślnie, żadne czeki sterty)

Domyślnie _CrtCheckMemory jest wywoływana jest raz dla każdego 1 024 razy wywołać malloc, realloc, wolnego, i _msize.

Na przykład, można określić, co 16 Sprawdzanie sterty malloc, realloc, wolnego, i _msize operacji z następującego kodu:

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

Górnym 16 bitów z newFlag parametr są ignorowane, gdy określono _CRTDBG_CHECK_ALWAYS_DF.In this case, _CrtCheckMemory is called each time you call malloc, realloc, free, and _msize.

newFlagto nowe Państwo, aby zastosować do _crtDbgFlag i jest kombinacją wartości dla każdego pola bitowa.

Aby zmienić jeden lub więcej z tych pól bitowych i Utwórz nowy stan flagi

Call _CrtSetDbgFlag z newFlag równą _CRTDBG_REPORT_FLAG uzyskać bieżące _crtDbgFlag Państwa i przechowywać zwrócona wartość w zmiennej tymczasowej.
Włącz wszystkie bity przez OR- ing zmiennej tymczasowej z odpowiednich masek bitowych (reprezentowane przez stałe manifestu w kodzie aplikacji).
Wyłączyć inne kawałki przez i- ing zmiennej z logiczną nie z odpowiednią masek bitowych.
Call _CrtSetDbgFlag z newFlag równe wartości przechowywane w zmiennej tymczasowej, aby ustawić nowy stan dla _crtDbgFlag.

Poniższy kod ilustruje sposób symulować małej ilości pamięci warunków utrzymując uwolniony bloków pamięci sterty połączonej liście i zapobiec _CrtCheckMemory wywoływana na każde żądanie alokacji:

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

Aby uzyskać omówienie zarządzania pamięcią i sterty debugowania, zobacz Zarządzanie pamięcią i debugowania sterty.

Aby wyłączyć flagi z _CrtSetDbgFlag funkcji, należy AND zmienna środowiskowa bitowe nie z maskę bitową.

Jeśli newFlag nie jest prawidłową wartością, funkcja ta wywołuje program obsługi nieprawidłowy parametr, zgodnie z opisem w Sprawdzanie poprawności parametru.Jeśli wykonanie może kontynuować, ta funkcja ustawia errno do EINVAL i zwraca poprzedniego stanu _crtDbgFlag.

Wymagania

Rozpoczęto wykonywanie procedury	Wymaganego nagłówka
_CrtSetDbgFlag	<crtdbg.h>

Informacji dotyczących zgodności, zobacz zgodności we wprowadzeniu.

Biblioteki

Program Debug: polecenie wersje biblioteki uruchomieniowej C tylko.

Przykład

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