`_CrtSetDbgFlag`

Artikel
10/12/2023

Mengambil atau memodifikasi status _crtDbgFlag bendera untuk mengontrol perilaku alokasi manajer timbunan debug (hanya versi debug).

Sintaks

int _CrtSetDbgFlag(
   int newFlag
);

Parameter

newFlag
Status baru untuk _crtDbgFlag.

Nilai hasil

Mengembalikan status sebelumnya dari _crtDbgFlag.

Keterangan

Fungsi ini _CrtSetDbgFlag memungkinkan aplikasi untuk mengontrol bagaimana manajer timbunan debug melacak alokasi memori dengan memodifikasi bidang _crtDbgFlag bit bendera. Dengan mengatur bidang bit, aplikasi dapat menginstruksikan manajer timbunan debug untuk melakukan operasi penelusuran kesalahan khusus. Ada beberapa kemungkinan operasi:

Memeriksa kebocoran memori ketika aplikasi keluar dan melaporkan jika ada yang ditemukan,
Mensimulasikan kondisi memori rendah dengan menentukan bahwa blok memori yang dibesarkan harus tetap berada dalam daftar timbunan yang ditautkan,
Memverifikasi integritas timbunan dengan memeriksa setiap blok memori pada setiap permintaan alokasi.

Jika _DEBUG tidak ditentukan, panggilan ke _CrtSetDbgFlag akan dihapus selama praproscesing.

Tabel berikut mencantumkan bidang bit untuk _crtDbgFlag dan menjelaskan perilakunya. Karena pengaturan bit menghasilkan peningkatan output diagnostik dan mengurangi kecepatan eksekusi program, bit ini tidak diatur (dimatikan) secara default. Untuk informasi selengkapnya tentang bidang bit ini, lihat Fungsi pelaporan status timbunan.

Bidang bit	Default	Deskripsi
`_CRTDBG_ALLOC_MEM_DF`	AKTIF	AKTIF: Aktifkan alokasi timbunan debug dan penggunaan pengidentifikasi jenis blok memori, seperti `_CLIENT_BLOCK`. NONAKTIF: Tambahkan alokasi baru ke daftar tertaut timbunan, tetapi atur jenis blok ke `_IGNORE_BLOCK`. Juga dapat dikombinasikan dengan salah satu makro pemeriksaan frekuensi tumpukan.
`_CRTDBG_CHECK_ALWAYS_DF`	TIDAK AKTIF	AKTIF: Hubungi `_CrtCheckMemory` setiap permintaan alokasi dan alokasi. NONAKTIF: `_CrtCheckMemory` harus dipanggil secara eksplisit. Makro pemeriksaan frekuensi tumpukan tidak berpengaruh ketika bendera ini diatur.
`_CRTDBG_CHECK_CRT_DF`	TIDAK AKTIF	AKTIF: Sertakan `_CRT_BLOCK` jenis dalam operasi deteksi kebocoran dan perbedaan status memori. NONAKTIF: Memori yang digunakan secara internal oleh pustaka run-time diabaikan oleh operasi ini. Juga dapat dikombinasikan dengan salah satu makro pemeriksaan frekuensi tumpukan.
`_CRTDBG_DELAY_FREE_MEM_DF`	TIDAK AKTIF	AKTIF: Simpan blok memori yang dibeberkan dalam daftar tertaut heap, tetapkan `_FREE_BLOCK` jenisnya, dan isi dengan nilai byte 0xDD. NONAKTIF: Jangan menyimpan blok yang dibeberkan dalam daftar timbunan yang ditautkan. Juga dapat dikombinasikan dengan salah satu makro pemeriksaan frekuensi tumpukan.
`_CRTDBG_LEAK_CHECK_DF`	TIDAK AKTIF	AKTIF: Lakukan pemeriksaan kebocoran otomatis di program keluar melalui panggilan ke `_CrtDumpMemoryLeaks` dan buat laporan kesalahan jika aplikasi gagal membebaskan semua memori yang dialokasikan. NONAKTIF: Jangan secara otomatis melakukan pemeriksaan kebocoran di pintu keluar program. Juga dapat dikombinasikan dengan salah satu makro pemeriksaan frekuensi tumpukan.

Makro Frekuensi Heap-Check

Anda dapat menentukan seberapa sering pustaka run-time C melakukan validasi timbunan debug (_CrtCheckMemory) berdasarkan jumlah panggilan ke malloc, realloc, free, dan _msize.

_CrtSetDbgFlag kemudian memeriksa 16 bit parameter atas newFlag untuk nilai. Nilai yang ditentukan adalah jumlah mallocpanggilan , , reallocfree, dan _msize antar _CrtCheckMemory panggilan. Empat makro yang telah ditentukan sebelumnya disediakan untuk tujuan ini.

Makro	Jumlah `malloc`panggilan , `realloc`, `free`, dan `_msize` antara panggilan ke `_CrtCheckMemory`
`_CRTDBG_CHECK_EVERY_16_DF`	16
`_CRTDBG_CHECK_EVERY_128_DF`	128
`_CRTDBG_CHECK_EVERY_1024_DF`	1024
`_CRTDBG_CHECK_DEFAULT_DF`	0 (secara default, tidak ada pemeriksaan timbunan)

Secara default, _CrtCheckMemory tidak dipanggil selama operasi memori. Anda dapat mengubahnya dengan mengirim bendera yang ditunjukkan di atas ke _CrtSetDbgFlag().

Misalnya, Anda dapat menentukan pemeriksaan timbunan setiap operasi 16 malloc, , reallocfree, dan _msize dengan kode berikut:

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

16 bit newFlag atas parameter diabaikan ketika _CRTDBG_CHECK_ALWAYS_DF ditentukan. Dalam hal ini, _CrtCheckMemory dipanggil setiap kali Anda memanggil malloc, , reallocfree, dan _msize.

newFlag adalah status baru untuk diterapkan ke _crtDbgFlag dan merupakan kombinasi dari nilai untuk setiap bidang bit.

Untuk mengubah satu atau beberapa bidang bit ini dan membuat status baru untuk bendera

Panggil _CrtSetDbgFlag dengan sama _CRTDBG_REPORT_FLAG dengan newFlag untuk mendapatkan status saat ini _crtDbgFlag dan simpan nilai yang dikembalikan dalam variabel sementara.
Aktifkan bit apa pun dengan bitwise "atau" (|) dari variabel sementara dengan bitmask yang sesuai (diwakili dalam kode aplikasi dengan konstanta manifes).
Matikan bit lain dengan bitwise "dan" (&) variabel dengan bitwise "not" (~) dari bitmask yang sesuai.
Panggil _CrtSetDbgFlag dengan sama dengan newFlag nilai yang disimpan dalam variabel sementara untuk mengatur status baru untuk _crtDbgFlag.

Kode berikut menunjukkan cara mensimulasikan kondisi memori rendah dengan menjaga blok memori yang dibebankan dalam daftar tertaut timbunan dan mencegah _CrtCheckMemory dipanggil pada setiap permintaan alokasi:

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

Untuk gambaran umum manajemen memori dan tumpukan debug, lihat detail tumpukan debug CRT.

Untuk menonaktifkan bendera dengan _CrtSetDbgFlag fungsi , gunakan bitwise "dan" (&) variabel dengan bitwise "not" (~) dari bitmask.

Jika newFlag bukan nilai yang valid, fungsi ini memanggil handler parameter yang tidak valid, seperti yang dijelaskan dalam Validasi parameter. Jika eksekusi diizinkan untuk melanjutkan, fungsi ini diatur errno ke EINVAL dan mengembalikan status sebelumnya dari _crtDbgFlag.

Persyaratan

Rutin	Header yang diperlukan
`_CrtSetDbgFlag`	`<crtdbg.h>`

Untuk informasi kompatibilitas selengkapnya, lihat Kompatibilitas.

Pustaka

Debug versi pustaka run-time C saja.

Contoh

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