C # unsicheren Code

Zeigervariable

Ein Zeiger ist ein variabler Wert der Adresse einer anderen Variablen, die direkte Adresse des Speicherplatzes , nämlich.Wie andere Variablen oder Konstanten, müssen Sie den Zeiger vor anderen Adresszeigerdeklaration Variablenspeicher verwenden.

Die allgemeine Form eines Zeigers Variablendeklaration:

Typ * var-name;

Hier finden Sie eine gültige Zeigerdeklaration:

int * ip; / * zeigt auf eine ganze Zahl * /
double * dp / * Zeiger auf eine Zahl mit doppelter Genauigkeit * /
schwimmen * fp / * Zeiger auf einen float * /
char * ch / * Zeiger auf ein char * /

Das folgende Beispiel veranschaulicht die Verwendung des C #unsichere Modifikator , wenn der Zeiger:

using System;
Namespace UnsafeCodeApplication
{
    Klasse-Programm
    {
        statisch unsicher void Main (string [] args)
        {
            int var = 20;
            int * p = & var;
            Console.WriteLine ( "Daten sind: {0}", var);
            Console.WriteLine ( "Adresse lautet: {0}", (int) p);
            Console.ReadKey ();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Die Daten sind: 20
Adresse lautet: 99215364

Sie können nicht das gesamte Verfahren als unsicher Code deklarieren, nur einen Teil der Notwendigkeit, das Verfahren als unsicher Code zu erklären. Das folgende Beispiel veranschaulicht diesen Punkt.

Abrufen von Datenwerten einen Zeiger mit

Sie können die MethodeToString () der Datenreferenzposition in einem Retrieval - Pointer - Variablen gespeichert sind .Das folgende Beispiel veranschaulicht diesen Punkt:

using System;
Namespace UnsafeCodeApplication
{
   Klasse-Programm
   {
      public static void Main ()
      {
         unsicher
         {
            int var = 20;
            int * p = & var;
            Console.WriteLine ( "Daten sind: {0}", var);
            Console.WriteLine ( "Daten sind: {0}", p-> ToString ());
            Console.WriteLine ( "Adresse lautet: {0}", (int) p);
         }
         Console.ReadKey ();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Die Daten sind: 20
Die Daten sind: 20
Adresse lautet: 77128984

Übergeben eines Zeigers als Parameter Methode

Sie können eine Zeigervariable als Parameter an die Methode der Annäherung übergeben. Das folgende Beispiel veranschaulicht diesen Punkt:

using System;
Namespace UnsafeCodeApplication
{
   Klasse TestPointer
   {
      öffentlich unsichere Leere swap (int * p, int * q)
      {
         temp = int * p;
         * P = * q;
         * Q = Temp;
      }

      Öffentlichkeit unsicher static void Main ()
      {
         TestPointer p = new TestPointer ();
         int var1 = 10;
         int var2 = 20;
         int * x = & var1;
         int * y = & var2;
         
         Console.WriteLine ( "Vor der Swap: var1: {0}, var2: {1}", var1, var2);
         p.swap (x, y);

         Console.WriteLine ( "Nach dem Tausch: var1: {0}, var2: {1}", var1, var2);
         Console.ReadKey ();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Vor Swap: var1: 10, var2: 20
Nach dem Tausch: var1: 20, var2: 10

Verwenden Sie Zeiger auf Array-Elemente zugreifen

In C # ist der Array-Name und ein Zeiger auf die Array-Daten mit dem gleichen Datentyp ein Zeiger auf eine andere Variablentypen. Zum Beispiel int * p und int [] p ist eine andere Art. Sie können die Zeigervariable p erhöhen, weil es nicht im Speicher festgelegt ist, aber die Adresse des Arrays im Speicher festgelegt, so können Sie ein Array p nicht hinzufügen.

Also, wenn Sie benötigen , um die Zeigervariablen zu verwenden , um die Array - Daten zugreifen zu können , wie wir in der Regel in C oder C ++ zu tun als Schlüsselwörterfest festen Zeiger zu verwenden.

Das folgende Beispiel veranschaulicht diesen Punkt:

using System;
Namespace UnsafeCodeApplication
{
   Klasse TestPointer
   {
      Öffentlichkeit unsicher static void Main ()
      {
         int [] list = {10, 100, 200};
         fest (int * ptr = Liste)

         / * Anzeige Zeigerfeld Adresse * /
         for (int i = 0; i <3; i ++)
         {
            Console.WriteLine ( "Adresse der Liste [{0}] = {1}", i, (int) (ptr + i));
            Console.WriteLine ( "Wert der Liste [{0}] = {1}", i, * (ptr + i));
         }
         Console.ReadKey ();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Adresse der Liste [0] = 31627168
Wert der Liste [0] = 10
Adresse der Liste [1] = 31627172
Wert der Liste [1] = 100
Adresse der Liste [2] = 31627176
Wert der Liste [2] = 200

Kompilieren unsicheren Code

Um unsicheren Code zu kompilieren, müssen Sie in der Befehlszeile Compiler schalten Sie den/ unsichere Befehlszeile angeben.

Zum Beispiel, ein Programm namens prog1.cs enthalten unsicheren Code, geben Sie den Befehl in der Befehlszeile zu kompilieren:

csc / unsichere prog1.cs

Wenn Sie Visual Studio IDE verwenden, müssen Sie unsicheren Code in den Projekteigenschaften zu ermöglichen.

Gehen Sie wie folgt vor:

• Mit einem Doppelklick auf Explorer (Lösung Explorer) Attribute (Eigenschaften) Knoten, öffnen Sie dieProjekteigenschaften (Projekteigenschaften).
• Klicken Sie auf die RegisterkarteErstellen.
• Wählen Sie die Option"Allow unsicheren Code".