C# Language
Zeiger und unsicherer Code

Einführung in unsicheren Code

C # erlaubt die Verwendung von Zeigervariablen in einer Funktion des Codeblocks, wenn dieser vom unsafe Modifikator markiert wird. Der unsichere Code oder der nicht verwaltete Code ist ein Codeblock, der eine Zeigervariable verwendet.

Ein Zeiger ist eine Variable, deren Wert die Adresse einer anderen Variablen ist, dh die direkte Adresse des Speicherplatzes. Ähnlich wie bei einer Variablen oder Konstante müssen Sie einen Zeiger deklarieren, bevor Sie ihn zum Speichern einer Variablenadresse verwenden können.

Die allgemeine Form einer Zeigerdeklaration lautet:

type *var-name;

Es folgen gültige Zeigerdeklarationen:

int    *ip;    /* pointer to an integer */
double *dp;    /* pointer to a double */
float  *fp;    /* pointer to a float */
char   *ch     /* pointer to a character */

Das folgende Beispiel veranschaulicht die Verwendung von Zeigern in C # mit dem unsicheren Modifikator:

using System;
namespace UnsafeCodeApplication
{
   class Program
   {
      static unsafe void Main(string[] args)
      {
         int var = 20;
         int* p = &var;
         Console.WriteLine("Data is: {0} ",  var);
         Console.WriteLine("Address is: {0}",  (int)p);
         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wurde, führt er zu folgendem Ergebnis:

Data is: 20
Address is: 99215364

Anstatt eine gesamte Methode als unsicher zu deklarieren, können Sie auch einen Teil des Codes als unsicher deklarieren:

// safe code
unsafe
{
    // you can use pointers here
}
// safe code

Datenwert mit einem Zeiger abrufen

Sie können die Daten abrufen, die an der durch die Zeigervariable referenzierten Stelle gespeichert wurden, mithilfe der ToString () - Methode. Das folgende Beispiel veranschaulicht dies:

using System;
namespace UnsafeCodeApplication
{
   class Program
   {
      public static void Main()
      {
         unsafe
         {
            int var = 20;
            int* p = &var;
            Console.WriteLine("Data is: {0} " , var);
            Console.WriteLine("Data is: {0} " , p->ToString());
            Console.WriteLine("Address is: {0} " , (int)p);
         }
         
         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wurde, führt er zu folgendem Ergebnis:

Data is: 20
Data is: 20
Address is: 77128984

Zeiger als Parameter an Methoden übergeben

Sie können eine Zeigervariable als Parameter an eine Methode übergeben. Das folgende Beispiel veranschaulicht dies:

using System;
namespace UnsafeCodeApplication
{
   class TestPointer
   {
      public unsafe void swap(int* p, int *q)
      {
         int temp = *p;
         *p = *q;
         *q = temp;
      }
      
      public unsafe static void Main()
      {
         TestPointer p = new TestPointer();
         int var1 = 10;
         int var2 = 20;
         int* x = &var1;
         int* y = &var2;
         
         Console.WriteLine("Before Swap: var1:{0}, var2: {1}", var1, var2);
         p.swap(x, y);

         Console.WriteLine("After Swap: var1:{0}, var2: {1}", var1, var2);
         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, führt er zu folgendem Ergebnis:

Before Swap: var1: 10, var2: 20
After Swap: var1: 20, var2: 10

Zugriff auf Array-Elemente mit einem Zeiger

In C # sind ein Arrayname und ein Zeiger auf einen Datentyp, der mit den Arraydaten identisch ist, nicht derselbe Variablentyp. Zum Beispiel sind int *p und int[] p nicht vom gleichen Typ. Sie können die Zeigervariable p inkrementieren, da sie nicht im Speicher festgelegt ist, sondern eine Array-Adresse im Speicher und Sie können diese nicht erhöhen.

Wenn Sie also wie in C oder C ++ auf eine Array-Daten mit einer Zeigervariable zugreifen müssen, müssen Sie den Zeiger mit dem festen Schlüsselwort korrigieren.

Das folgende Beispiel veranschaulicht dies:

using System;
namespace UnsafeCodeApplication
{
   class TestPointer
   {
      public unsafe static void Main()
      {
         int[]  list = {10, 100, 200};
         fixed(int *ptr = list)
         
         /* let us have array address in pointer */
         for ( int i = 0; i < 3; i++)
         {
            Console.WriteLine("Address of list[{0}]={1}",i,(int)(ptr + i));
            Console.WriteLine("Value of list[{0}]={1}", i, *(ptr + i));
         }
         
         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wurde, führt er zu folgendem Ergebnis:

Address of list[0] = 31627168
Value of list[0] = 10
Address of list[1] = 31627172
Value of list[1] = 100
Address of list[2] = 31627176
Value of list[2] = 200

Unsicheren Code kompilieren

Um unsicheren Code zu kompilieren, müssen Sie den Befehlszeilenschalter /unsafe mit dem Befehlszeilencompiler angeben.

Um beispielsweise ein Programm mit dem Namen prog1.cs zu kompilieren, das unsicheren Code enthält, geben Sie den folgenden Befehl von der Befehlszeile aus:

csc /unsafe prog1.cs

Wenn Sie Visual Studio IDE verwenden, müssen Sie in den Projekteigenschaften die Verwendung von unsicherem Code aktivieren.

Um dies zu tun:

• Öffnen Sie die Projekteigenschaften, indem Sie im Projektmappen-Explorer auf den Eigenschaftsknoten doppelklicken.
• Klicken Sie auf die Registerkarte "Erstellen".
• Wählen Sie die Option "Unsicheren Code zulassen".