Code dangereux C#

Variable pointeur

Un pointeur est une variable dont la valeur est l'adresse d'une autre variable, c'est-à-dire l'adresse directe d'un emplacement mémoire. Tout comme les autres variables ou constantes, vous devez déclarer un pointeur avant de l'utiliser pour stocker l'adresse d'une autre variable.

La forme générale de déclaration de variable de pointeur est :

type *var-name;

Les déclarations de pointeur suivantes sont valides :

int    *ip;    /* 指向一个整数 */
double *dp;    /* 指向一个双精度数 */
float  *fp;    /* 指向一个浮点数 */
char   *ch     /* 指向一个字符 */

L'exemple suivant illustre l'utilisation de unsafe<🎜 dans C# > Utilisation de pointeurs lorsque le modificateur :

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

Lorsque le code ci-dessus est compilé et exécuté, il produira les résultats suivants :

Data is: 20
Address is: 99215364

Vous pouvez également éviter de déclarer la méthode entière comme code dangereux, Seule une partie de la méthode doit être déclarée comme code non sécurisé. L’exemple suivant illustre ce point.

Récupération de valeurs de données à l'aide de pointeurs

Vous pouvez utiliser la méthode

ToString() pour récupérer des données stockées à l'emplacement référencé par une variable de pointeur. L'exemple suivant le démontre :

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

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

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

Passer un pointeur en tant que paramètre de méthode

Vous pouvez transmettre des variables de pointeur aux méthodes en tant que paramètres de la méthode. L'exemple suivant illustre ceci :

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

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

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

Utilisation de pointeurs pour accéder aux éléments du tableau

In In C# , un nom de tableau et un pointeur vers le même type de données que les données du tableau sont des types de variables différents. Par exemple, int *p et int[] p sont des types différents. Vous pouvez incrémenter la variable de pointeur p car elle n'est pas fixe en mémoire, mais l'adresse du tableau est fixe en mémoire, vous ne pouvez donc pas incrémenter le tableau p.

Ainsi, si vous avez besoin d'accéder aux données du tableau à l'aide d'une variable de pointeur, vous pouvez corriger le pointeur à l'aide du mot-clé

fixed comme nous le faisons habituellement en C ou C++.

L'exemple suivant le démontre :

using System;
namespace UnsafeCodeApplication
{
   class TestPointer
   {
      public unsafe static void Main()
      {
         int[]  list = {10, 100, 200};
         fixed(int *ptr = list)

         /* 显示指针中数组地址 */
         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();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

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

Compilation de code non sécurisé

Afin de compiler du code dangereux, vous devez passer au compilateur de ligne de commande et spécifier la ligne de commande

/unsafe.

Par exemple, pour compiler un programme nommé prog1.cs qui contient du code non sécurisé, entrez la commande sur la ligne de commande :

csc /unsafe prog1.cs

Si vous utilisez l'IDE Visual Studio, vous devez activer unsafe code dans les propriétés du projet.

Les étapes sont les suivantes :

• Ouvrez les

  propriétés du projet<🎜 en double-cliquant sur le nœud des propriétés dans l'Explorateur de solutions >.

Cliquez sur l'onglet
• Construire

  .

Sélectionnez l'option "
• Autoriser les codes dangereux

  ".