Latest web development tutorials

direttive del preprocessore # C

Istruire il preprocessore compilatore prima dell'inizio effettivo compilazione del pretrattamento informazioni.

Tutte le direttive del preprocessore iniziano con #. E su una linea, solo i caratteri vuoti possono apparire prima di una direttiva del preprocessore. direttiva del preprocessore non è una dichiarazione, quindi non sono un punto e virgola; end ().

C # compilatore non ha un pre-processore separato, tuttavia, avere un preprocessore separato come istruzione viene elaborata. In C #, le direttive del preprocessore per il lavoro la compilazione condizionale. C e C ++ non hanno diverse istruzioni, non sono utilizzati per creare una macro. Una direttiva del preprocessore deve essere l'unica istruzione su quella linea.

C lista direttive del preprocessore #

La seguente tabella elenca le direttive del preprocessore C # sono disponibili:

预处理器指令描述
#define它用于定义一系列成为符号的字符。
#undef它用于取消定义符号。
#if它用于测试符号是否为真。
#else它用于创建复合条件指令，与 #if 一起使用。
#elif它用于创建复合条件指令。
#endif指定一个条件指令的结束。
#line它可以让您修改编译器的行数以及（可选地）输出错误和警告的文件名。
#error它允许从代码的指定位置生成一个错误。
#warning它允许从代码的指定位置生成一级警告。
#region它可以让您在使用 Visual Studio Code Editor 的大纲特性时，指定一个可展开或折叠的代码块。
#endregion它标识着 #region 块的结束。

preprocessore #define

direttiva del preprocessore #define crea costanti simboliche.

#define consente di definire un simbolo, in modo che, attraverso l'uso del simbolo è passato all'espressione direttiva #if come espressione restituisce true. La sua sintassi è la seguente: 

simbolo #define

Il seguente programma illustra questo punto: 

#define PI 
using System;
PreprocessorDAppl namespace
{
   Programma di classe
   {
      static void Main (string [] args)
      {
         #if (PI)
            Console.WriteLine ( "PI è definita");
         #else
            Console.WriteLine ( "PI non è definito");
         #endif
         Console.ReadKey ();
      }
   }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati: 

PI è definita

le istruzioni condizionali

È possibile utilizzare la direttiva #if per creare un'istruzione condizionale. le istruzioni condizionali per testare se il simbolo è vero. Se fosse vero, il compilatore eseguirà il codice tra #if e l'istruzione successiva.

Sintassi di istruzione condizionale: 

#if simbolo [simbolo operator] ...

In cui,simbolo è il nome simbolico da testare. È inoltre possibile utilizzare vero e falso, o un simbolo è posto di fronte l'operatore di negazione.

simboli operatoresono utilizzati per valutare il simbolo dell'operatore. Gli operatori possono essere uno dei seguenti operatori:

  • == (Uguaglianza)
  • ! = (Diseguaglianza)
  • && (E)
  • || (O)

È inoltre possibile utilizzare le parentesi per simboli e operatori del gruppo. l'istruzione condizionale nella versione debug o compilare il codice di configurazione compilato specificato. Un'istruzione condizionalea partire dalladirettiva#if,deve essere esposto in una istruzione#endifè chiuso.

Il seguente programma illustra l'utilizzo di istruzioni condizionali: 

DEBUG #define
#define VC_V10
using System;
public class TestClass
{
   public static void Main ()
   {

      #if (DEBUG &&! VC_V10)
         Console.WriteLine ( "DEBUG è definito");
      #elif (! DEBUG && VC_V10)
         Console.WriteLine ( "VC_V10 è definita");
      #elif (DEBUG && VC_V10)
         Console.WriteLine ( "DEBUG e VC_V10 sono definiti");
      #else
         Console.WriteLine ( "DEBUG e VC_V10 non sono definiti");
      #endif
      Console.ReadKey ();
   }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati: 

DEBUG e VC_V10 sono definiti