float_control pragma

Menentukan perilaku floating-point untuk fungsi.

Sintaks

#pragma float_control
#pragma float_control( precise, { on | off } [ , push ] )
#pragma float_control( except, { on | off } [ , push ] )
#pragma float_control( { push | pop } )

Opsi

precise, , on | offpush
Menentukan apakah akan mengaktifkan (on) atau menonaktifkan (off) semantik floating-point yang tepat. Untuk informasi tentang perbedaan dengan /fp:precise opsi pengkompilasi, lihat bagian Keterangan. Token opsional push mendorong pengaturan saat ini untuk float_control pada tumpukan kompilator internal.

except, , on | offpush
Menentukan apakah akan mengaktifkan (on) atau menonaktifkan (off) semantik pengecualian floating-point. Token opsional push mendorong pengaturan saat ini untuk float_control pada tumpukan kompilator internal.

except hanya dapat diatur ke on kapan precise juga diatur ke on.

push
Mendorong pengaturan saat ini float_control ke tumpukan kompilator internal.

pop
float_control Menghapus pengaturan dari bagian atas tumpukan kompilator internal, dan menjadikannya pengaturan barufloat_control.

Keterangan

float_control pragma tidak memiliki perilaku yang sama dengan /fp opsi kompilator. Satu-satunya float_controlpragma mengatur bagian dari perilaku floating-point. Ini harus dikombinasikan dengan fp_contract dan fenv_accesspragma direktif untuk membuat /fp ulang opsi pengompilasi. Tabel berikut ini memperlihatkan pengaturan yang setara pragma untuk setiap opsi pengkompilasi:

Opsi	float_control(precise, *)	float_control(except, *)	fp_contract(*)	fenv_access(*)
/fp:strict	on	on	off	on
/fp:precise	on	off	off*	off
/fp:fast	off	off	on	off

* Dalam versi Visual Studio sebelum Visual Studio 2022, /fp:precise perilaku default ke fp_contract(on).

Dengan kata lain, Anda mungkin perlu menggunakan beberapa pragma direktif dalam kombinasi untuk meniru /fp:fastopsi baris perintah , /fp:precise, dan /fp:strict .

Ada batasan cara Anda dapat menggunakan float_control direktif floating-point fenv_access dan pragma dalam kombinasi:

• Anda hanya dapat menggunakan float_control untuk mengatur except ke on jika semantik yang tepat diaktifkan. Semantik yang tepat dapat diaktifkan baik oleh float_controlpragma, atau dengan menggunakan /fp:precise opsi atau /fp:strict pengkompilasi.

• Anda tidak dapat menggunakan untuk menonaktifkan float_control saat semantik pengecualian diaktifkan, baik oleh precisefloat_control opsi pengkompilasi atau pragma ./fp:except

• Anda tidak dapat mengaktifkan fenv_access kecuali semantik yang tepat diaktifkan, baik oleh float_controlpragma opsi atau pengkompilasi.

• Anda tidak dapat menggunakan float_control untuk menonaktifkan precise saat fenv_access diaktifkan.

Pembatasan ini berarti urutan beberapa arahan floating-point pragma signifikan. Untuk beralih dari model cepat ke model ketat menggunakan pragma direktif, gunakan kode berikut:

#pragma float_control(precise, on)  // enable precise semantics
#pragma fenv_access(on)             // enable environment sensitivity
#pragma float_control(except, on)   // enable exception semantics

Untuk beralih dari model ketat ke model cepat dengan menggunakan float_controlpragma, gunakan kode berikut:

#pragma float_control(except, off)  // disable exception semantics
#pragma fenv_access(off)            // disable environment sensitivity
#pragma float_control(precise, off) // disable precise semantics
#pragma fp_contract(on)             // enable contractions

Jika tidak ada opsi yang ditentukan, float_control tidak berpengaruh.

Direktif float_control menonaktifkan kontraksi saat menyala precise atau except. Penggunaan float_control untuk menonaktifkan precise atau except memulihkan pengaturan sebelumnya untuk kontraksi. Anda dapat menggunakan direktif fp_contractpragma untuk mengubah perilaku pengkompilasi pada kontraksi. float_control(push) dan float_control(pop) dorong dan pop pengaturan untuk kontraksi sebagai bagian float_control dari pengaturan ke tumpukan kompiler internal. Perilaku ini baru di Visual Studio 2022. Arahan float_control dalam versi kompilator sebelumnya tidak memengaruhi pengaturan kontraksi.

Contoh

Sampel berikut menunjukkan cara menangkap pengecualian floating-point luapan dengan menggunakan pragmafloat_control.

// pragma_directive_float_control.cpp
// compile with: /EHa
#include <stdio.h>
#include <float.h>

double func( ) {
   return 1.1e75;
}

#pragma float_control (except, on)

int main( ) {
   float u[1];
   unsigned int currentControl;
   errno_t err;

   err = _controlfp_s(&currentControl, ~_EM_OVERFLOW, _MCW_EM);
   if (err != 0)
      printf_s("_controlfp_s failed!\n");

   try  {
      u[0] = func();
      printf_s ("Fail");
      return(1);
   }

   catch (...)  {
      printf_s ("Pass");
      return(0);
   }
}

Pass

Lihat juga

arahan Pragma dan kata kunci __pragma dan _Pragma
fenv_access pragma
fp_contract pragma