C# Language
Aanwijzers & onveilige code

Inleiding tot onveilige code

Met C # kunnen pointervariabelen worden gebruikt in een functie van een codeblok wanneer dit wordt gemarkeerd door de unsafe modifier. De onveilige code of de onbeheerde code is een codeblok dat een pointervariabele gebruikt.

Een pointer is een variabele waarvan de waarde het adres is van een andere variabele, dat wil zeggen het directe adres van de geheugenlocatie. vergelijkbaar met elke variabele of constante, moet u een aanwijzer declareren voordat u deze kunt gebruiken om een variabel adres op te slaan.

De algemene vorm van een pointerverklaring is:

type *var-name;

Hierna volgen geldige aanwijsverklaringen:

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

Het volgende voorbeeld illustreert het gebruik van verwijzingen in C # met behulp van de onveilige modifier:

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();
      }
   }
}

Wanneer de bovenstaande code is gecompileerd en uitgevoerd, levert dit het volgende resultaat op:

Data is: 20
Address is: 99215364

In plaats van een hele methode als onveilig te verklaren, kunt u ook een deel van de code als onveilig verklaren:

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

De gegevenswaarde ophalen met een aanwijzer

U kunt de gegevens ophalen die zijn opgeslagen op de locatie waarnaar wordt verwezen door de variabele pointer, met behulp van de methode ToString (). Het volgende voorbeeld laat dit zien:

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();
      }
   }
}

Toen de bovenstaande code werd gecompileerd en uitgevoerd, levert dit het volgende resultaat op:

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

Aanwijzers doorgeven als parameters aan methoden

U kunt een pointervariabele als parameter doorgeven aan een methode. Het volgende voorbeeld illustreert dit:

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();
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op:

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

Toegang tot matrixelementen met een aanwijzer

In C # zijn een matrixnaam en een aanwijzer naar een gegevenstype hetzelfde als de matrixgegevens, niet hetzelfde variabele type. int *p en int[] p zijn bijvoorbeeld niet van hetzelfde type. U kunt de pointervariabele p verhogen omdat deze niet in het geheugen is vastgelegd, maar een array-adres in het geheugen is vastgelegd, en u kunt dat niet verhogen.

Daarom moet u de aanwijzer met behulp van het vaste trefwoord corrigeren als u toegang wilt krijgen tot matrixgegevens met behulp van een pointervariabele, zoals we traditioneel doen in C of C ++.

Het volgende voorbeeld laat dit zien:

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();
      }
   }
}

Toen de bovenstaande code werd gecompileerd en uitgevoerd, levert dit het volgende resultaat op:

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

Onveilige code samenstellen

Voor het compileren van onveilige code moet u de /unsafe opdrachtregelschakelaar met opdrachtregelcompiler opgeven.

Om bijvoorbeeld een programma met de naam prog1.cs te compileren dat onveilige code bevat, vanaf de opdrachtregel, geeft u de opdracht:

csc /unsafe prog1.cs

Als u Visual Studio IDE gebruikt, moet u het gebruik van onveilige code inschakelen in de projecteigenschappen.

Om dit te doen:

• Open projecteigenschappen door te dubbelklikken op het eigenschappenknooppunt in Solution Explorer.
• Klik op het tabblad Build.
• Selecteer de optie "Onveilige code toestaan"