Industriële fabricage
Industrieel internet der dingen | Industriële materialen | Onderhoud en reparatie van apparatuur | Industriële programmering |
home  MfgRobots >> Industriële fabricage >  >> Industrial programming >> C Taal

C# - Onveilige codes

C# staat het gebruik van aanwijzervariabelen toe in een functie van codeblok wanneer het is gemarkeerd door de onveilige modificator. De onveilige code of de onbeheerde code is een codeblok dat een pointer . gebruikt variabel.

Aanwijzingen

Een aanwijzer is een variabele waarvan de waarde het adres is van een andere variabele, d.w.z. het directe adres van de geheugenlocatie. vergelijkbaar met een 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 pointerdeclaratie is −

type *var-name;

Hieronder volgen geldige pointerverklaringen −

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 aanwijzers 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 onveilig te verklaren, kun je ook een deel van de code onveilig verklaren. Het voorbeeld in de volgende sectie laat dit zien.

De gegevenswaarde ophalen met een aanwijzer

U kunt de gegevens ophalen die zijn opgeslagen op de locatie waarnaar wordt verwezen door de aanwijzervariabele, met behulp van de ToString() methode. 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 naar methoden

U kunt een pointervariabele als parameter aan een methode doorgeven. 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 array-elementen met een aanwijzer

In C# zijn een arraynaam en een aanwijzer naar een gegevenstype dat hetzelfde is als de arraygegevens, niet hetzelfde variabeletype. Int *p en int[] p zijn bijvoorbeeld niet van hetzelfde type. U kunt de pointervariabele p verhogen omdat deze niet vast in het geheugen staat, maar een arrayadres vast in het geheugen, en u kunt dat niet verhogen.

Daarom, als u toegang wilt krijgen tot een array-gegevens met behulp van een pointervariabele, zoals we traditioneel doen in C of C++ (controleer:C Pointers), moet u de pointer repareren met behulp van de vaste zoekwoord.

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

Wanneer de bovenstaande code is 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 compileren

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

Als u bijvoorbeeld een programma met de naam prog1.cs met onveilige code wilt compileren vanaf de opdrachtregel, geeft u het commando −

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 de Solution Explorer.

  • Klik op de Build tabblad.

  • Selecteer de optie "Onveilige code toestaan ".


C Taal

  1. Kleurcodes weerstand
  2. Kleurcodes bedrading
  3. Infografische kleurcodes bedrading
  4. C++-aanwijzers met voorbeelden
  5. Pointers in C:Wat is Pointer in C-programmering? Soorten
  6. C - Aanwijzers
  7. Datamatrixcodes versus QR-codes
  8. Haas Mill M-codes
  9. Mach3 M-codes
  10. M-codes – CNC-programmeerquiz
  11. G-codes – CNC-programmeerquiz