C# Language
Pekare och osäker kod

Introduktion till osäker kod

C # tillåter att använda pekarvariabler i en funktion av kodblocket när den markeras av den unsafe modifieraren. Den osäkra koden eller den okontrollerade koden är ett kodblock som använder en pekvariabel.

En pekare är en variabel vars värde är adressen till en annan variabel, dvs. den direkta adressen till minnesplatsen. som liknar vilken variabel som helst eller konstant, måste du deklarera en pekare innan du kan använda den för att lagra någon variabeladress.

Den allmänna formen för en pekardeklaration är:

type *var-name;

Följande är giltiga pekardeklarationer:

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

Följande exempel illustrerar användningen av pekare i C # med den osäkra modifieraren:

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

När koden ovan kompilerades och körs ger den följande resultat:

Data is: 20
Address is: 99215364

Istället för att förklara en hel metod som osäker kan du också förklara en del av koden som osäker:

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

Hämta datavärdet med en pekare

Du kan hämta data lagrade på den plats som referensvariabeln refererar till med hjälp av metoden ToString (). Följande exempel visar detta:

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

När koden ovan kompilerades och körs ger den följande resultat:

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

Vidarebefordra pekare som parametrar till metoder

Du kan skicka en pekvariabel till en metod som parameter. Följande exempel illustrerar detta:

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

När koden ovan kompileras och körs ger den följande resultat:

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

Öppna arrayelement med en pekare

I C # är ett matrisnamn och en pekare till en datatyp som är samma som matrisdata inte samma variabeltyp. Exempelvis är int *p och int[] p inte samma typ. Du kan öka pekvariabeln p eftersom den inte är fixerad i minnet utan en matrisadress är fixerad i minnet och du kan inte öka det.

Därför, om du behöver få tillgång till en matrisdata med en pekvariabel, som vi traditionellt gör i C eller C ++, måste du fixa pekaren med det fasta nyckelordet.

Följande exempel visar detta:

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

När koden ovan kompilerades och körs ger den följande resultat:

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

Kompilera osäker kod

För att sammanställa osäker kod måste du ange /unsafe kommandoradsknapp med kommandoradskompilator.

Till exempel, för att kompilera ett program som heter prog1.cs som innehåller osäker kod, från kommandoraden, ge kommandot:

csc /unsafe prog1.cs

Om du använder Visual Studio IDE måste du aktivera användning av osäker kod i projektegenskaperna.

Att göra detta:

• Öppna projektegenskaper genom att dubbelklicka på egenskapsnoden i Solution Explorer.
• Klicka på fliken Bygg.
• Välj alternativet "Tillåt osäker kod"