C # Code dangereux

la variable Pointer

Un pointeur est une valeur variable de l'adresse d' une autre variable, à savoir, l'adresse directe de l'emplacement de mémoire.Comme d'autres variables ou constantes, vous devez utiliser le pointeur avant stockage d'autres variables déclaration adresse de pointeur.

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

var nom-de type *;

Ce qui suit est une déclaration de pointeur valide:

int * ip; / * pointe vers un entier * /
double * dp; / * pointeur vers un nombre double précision * /
float * fp; / * pointeur sur un flotteur * /
char * ch / * pointeur vers un char * /

L'exemple suivant illustre l'utilisation du C # en utilisant le modificateurdangereux lorsque le pointeur:

using System;
namespace UnsafeCodeApplication
{
    Programme de classe
    {
        statique dangereuse void Main (string [] args)
        {
            int var = 20;
            int * p = & var;
            Console.WriteLine ( "Data est: {0}", var);
            Console.WriteLine ( "L'adresse est: {0}", (int) p);
            Console.ReadKey ();
        }
    }
}

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

Les données sont: 20
L'adresse est: 99215364

Vous ne pouvez pas déclarer l'ensemble de la méthode code dangereux, une partie seulement de la nécessité de déclarer la méthode code dangereux. L'exemple suivant illustre ce point.

Récupération des valeurs de données en utilisant un pointeur

Vous pouvez utiliser la méthodeToString () des données de position de référence stockées dans une variables de pointeur de récupération.L'exemple suivant illustre ce point:

using System;
namespace UnsafeCodeApplication
{
   Programme de classe
   {
      public static void Main ()
      {
         dangereux
         {
            int var = 20;
            int * p = & var;
            Console.WriteLine ( "Data est: {0}", var);
            Console.WriteLine ( "Data est: {0}", p-> ToString ());
            Console.WriteLine ( "L'adresse est: {0}", (int) p);
         }
         Console.ReadKey ();
      }
   }
}

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

Les données sont: 20
Les données sont: 20
L'adresse est: 77128984

Le passage d'un pointeur comme une méthode de paramètre

Vous pouvez passer une variable de pointeur comme un paramètre à la méthode d'approche. L'exemple suivant illustre ce point:

using System;
namespace UnsafeCodeApplication
{
   classe TestPointer
   {
      swap de vide dangereux publique (int * p, int q *)
      {
         int temp = * p;
         * P * = q;
         * Q = température;
      }

      public void statique dangereuse Main ()
      {
         TestPointer p = new TestPointer ();
         int var1 = 10;
         int var2 = 20;
         int * x = & var1;
         int * y = & var2;
         
         Console.WriteLine ( "Avant Swap: var1: {0}, var2: {1}", var1, var2);
         p.swap (x, y);

         Console.WriteLine ( "Après 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:

Avant Swap: var1: 10, var2: 20
Après Swap: var1: 20, var2: 10

Utilisez des pointeurs pour accéder à des éléments de tableau

En C #, le nom du tableau et un pointeur vers les données de tableau avec le même type de données est un pointeur vers un différents types de variables. Par exemple, int * p et int [] p est un type différent. Vous pouvez augmenter la variable pointeur p, car il est pas fixé dans la mémoire, mais l'adresse du tableau est fixe dans la mémoire, de sorte que vous ne pouvez pas ajouter un tableau p.

Donc, si vous avez besoin d'utiliser les variables de pointeur pour accéder aux données de tableau, comme nous le faisons habituellement en C ou C ++ comme mots - clés pour utiliser le pointeur fixefixe.

L'exemple suivant illustre ce point:

using System;
namespace UnsafeCodeApplication
{
   classe TestPointer
   {
      public void statique dangereuse Main ()
      {
         int [] list = {10, 100, 200};
         fixe (int * ptr = liste)

         / * Affichage pointeur adresse de tableau * /
         for (int i = 0; i <3; i ++)
         {
            Console.WriteLine ( "Adresse de la liste [{0}] = {1}", i, (int) (ptr + i));
            Console.WriteLine ( "Valeur de la liste [{0}] = {1}", i, * (ptr + i));
         }
         Console.ReadKey ();
      }
   }
}

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

Adresse de la liste [0] = 31627168
Valeur de la liste [0] = 10
Adresse de la liste [1] = 31627172
Valeur de la liste [1] = 100
Adresse de la liste [2] = 31627176
Valeur de la liste [2] = 200

Compiler du code dangereux

Pour compiler le code dangereux, vous devez passer au compilateur de ligne de commande spécifier ladangereuse ligne de commande /.

Par exemple, pour compiler un programme appelé prog1.cs contiennent du code dangereux, entrez la commande à la ligne de commande:

csc / prog1.cs dangereuses

Si vous utilisez Visual Studio IDE, vous devez activer le code dangereux dans les propriétés du projet.

Procédez comme suit:

• En double-cliquant sur Explorer (Explorateur de solutions) attributs (propriétés) noeud, ouvrez lespropriétés du projet (propriétés du projet).
• Cliquez sur l'ongletGénérer.
• Sélectionnez l'option"Autoriser le code dangereux».