Arahan Pragma dan __pragma_Pragma kata kunci

Arahan Pragma menentukan fitur kompilator khusus mesin atau sistem operasi khusus. Baris yang dimulai dengan #pragma menentukan arahan pragma . Kata kunci khusus __pragma Microsoft memungkinkan Anda membuat kode pragma direktif dalam definisi makro. Operator preprocessor standar _Pragma , yang diperkenalkan di C99 dan diadopsi oleh C++11, serupa.

Sintaks

#pragmatoken-string
__pragma(token-string) // dua garis bawah terkemuka - Ekstensi khusus Microsoft
_Pragma(string-literal) // C99

Keterangan

Setiap implementasi C dan C++ mendukung beberapa fitur yang unik untuk komputer host atau sistem operasinya. Beberapa program, misalnya, harus menjalankan kontrol yang tepat atas lokasi data dalam memori, atau mengontrol cara fungsi tertentu menerima parameter. Direktif #pragma ini menawarkan cara bagi setiap kompilator untuk menawarkan fitur khusus komputer dan sistem operasi, sambil mempertahankan kompatibilitas keseluruhan dengan bahasa C dan C++.

Arahan Pragma khusus mesin atau khusus sistem operasi berdasarkan definisi, dan biasanya berbeda untuk setiap kompilator. pragma dapat digunakan dalam direktif kondisional, untuk menyediakan fungsionalitas prapemrosan baru. Atau, gunakan salah satu untuk memberikan informasi yang ditentukan implementasi kepada pengkompilasi.

String token adalah serangkaian karakter yang mewakili instruksi dan argumen pengkompilasi tertentu, jika ada. Tanda angka (#) harus menjadi karakter spasi non-putih pertama pada baris yang berisi pragma. Karakter spasi putih dapat memisahkan tanda angka dan kata "pragma". Mengikuti #pragma, tulis teks apa pun yang dapat diurai penerjemah sebagai token praproses. Argumen ke #pragma tunduk pada ekspansi makro.

String-literal adalah input ke _Pragma. Tanda kutip luar dan spasi kosong di depan/di belakang dihapus. \" diganti dengan " dan \\ diganti dengan \.

Kompilator mengeluarkan peringatan ketika menemukan pragma bahwa ia tidak mengenali, dan melanjutkan kompilasi.

Pengkompilasi Microsoft C dan C++ mengenali arahan berikut pragma :

alloc_text
auto_inline
bss_seg
check_stack
code_seg
comment
component
conform¹
const_seg
data_seg
deprecated

detect_mismatch
endregion
fenv_access
float_control
fp_contract
function
hdrstop
include_alias
init_seg¹
inline_depth
inline_recursion

intrinsic
loop¹
make_public
managed
message
omp
once
optimize
pack
pointers_to_members¹
pop_macro

push_macro
region
runtime_checks
section
setlocale
strict_gs_check
system_header
unmanaged
vtordisp¹
warning

¹ Hanya didukung oleh pengkompilasi C++.

Direktif Pragma dan opsi kompilator

Beberapa pragma direktif menyediakan fungsionalitas yang sama dengan opsi kompilator. pragma Ketika tercapai dalam kode sumber, itu mengambil alih perilaku yang ditentukan oleh opsi pengkompilasi. Misalnya, jika Anda menentukan /Zp8, Anda dapat mengambil alih pengaturan kompilator ini untuk bagian tertentu dari kode dengan pack:

cl /Zp8 some_file.cpp

// some_file.cpp - packing is 8
// ...
#pragma pack(push, 1) - packing is now 1
// ...
#pragma pack(pop) - packing is 8 again
// ...

Kata kunci __pragma

Pengkompilasi juga mendukung kata kunci khusus __pragma Microsoft, yang memiliki fungsionalitas yang sama dengan arahan #pragma . Perbedaannya adalah, __pragma kata kunci dapat digunakan sebaris dalam definisi makro. Direktif #pragma tidak dapat digunakan dalam definisi makro, karena pengkompilasi menginterpretasikan karakter tanda angka ('#') dalam direktif sebagai operator stringizing (#).

Contoh kode berikut menunjukkan bagaimana __pragma kata kunci dapat digunakan dalam makro. Kode ini dikutip dari header mfcdual.h dalam sampel ACDUAL di "Sampel Dukungan COM Compiler":

#define CATCH_ALL_DUAL \
CATCH(COleException, e) \
{ \
_hr = e->m_sc; \
} \
AND_CATCH_ALL(e) \
{ \
__pragma(warning(push)) \
__pragma(warning(disable:6246)) /*disable _ctlState prefast warning*/ \
AFX_MANAGE_STATE(pThis->m_pModuleState); \
__pragma(warning(pop)) \
_hr = DualHandleException(_riidSource, e); \
} \
END_CATCH_ALL \
return _hr; \

Operator _Pragma pra-pemrosesan

_Pragma mirip dengan kata kunci khusus __pragma Microsoft. Ini diperkenalkan ke dalam standar C di C99, dan standar C++ di C++11. Ini tersedia di C hanya saat Anda menentukan opsi atau /std:c17 ./std:c11 Untuk C++, tersedia di semua /std mode, termasuk default.

Tidak seperti #pragma, _Pragma memungkinkan Anda untuk memasukkan pragma arahan ke dalam definisi makro. String harfiah harus menjadi apa yang akan Anda letakkan mengikuti #pragma pernyataan. Contohnya:

#pragma message("the #pragma way")
_Pragma ("message( \"the _Pragma way\")") 

Tanda kutip dan garis miring belakang harus diloloskan, seperti yang ditunjukkan di atas. String pragma yang tidak dikenali diabaikan.

Contoh kode berikut menunjukkan bagaimana _Pragma kata kunci dapat digunakan dalam makro seperti pernyataan. Ini membuat pragma direktif yang menekan peringatan ketika ekspresi kondisi terjadi konstan.

Definisi makro menggunakan do ... while(0) idiom untuk makro multi-pernyataan sehingga dapat digunakan seolah-olah itu adalah satu pernyataan. Untuk informasi selengkapnya, lihat Makro multibaris C di Stack Overflow. Pernyataan _Pragma dalam contoh hanya berlaku untuk baris kode yang mengikutinya.

// Compile with /W4

#include <stdio.h>
#include <stdlib.h>

#define MY_ASSERT(BOOL_EXPRESSION) \
    do { \
        _Pragma("warning(suppress: 4127)") /* C4127 conditional expression is constant */  \
        if (!(BOOL_EXPRESSION)) {   \
            printf("MY_ASSERT FAILED: \"" #BOOL_EXPRESSION "\" on %s(%d)", __FILE__, __LINE__); \
            exit(-1); \
        } \
    } while (0)

int main()
{
    MY_ASSERT(0 && "Note that there is no warning: C4127 conditional expression is constant");

    return 0;
}

Baca juga

Referensi praprosesor C/C++
Arahan C pragma
Kata kunci