Pointeurs en C#

Les pointeurs sont définis comme une variable qui contient l'adresse mémoire d'une autre variable. Les pointeurs en C# sont utilisés chaque fois qu'il existe une instruction dangereuse et marquée par un mot-clé non sécurisé. Ces types d'instructions ne contrôlent pas les garbage collector et utilisent des variables de pointeur.

Syntaxe : Les pointeurs peuvent être déclarés comme

type  *var name;
int* a;

Ici * est appelé un opérateur de déréférencement et a est la variable qui contient l'adresse de type int.

Exemple

int *p = & x;    // where &x is the memory address of x
Console.WriteLine((int)p) // displaying memory address
Console.WriteLine(*p) // displaying value at memory address

Comment fonctionnent les pointeurs en C# ?

Vous trouverez ci-dessous les exemples qui montrent comment cela fonctionne en C#.

Pointeurs en C# – Exemple n°1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Pointers
{
class Demo
{
public void Method()
{
unsafe
{
int a = 40;
int b = 20;
int* ptr1 = &a;
int* ptr2 = &b;
Console.WriteLine(*ptr1);    // displaying the value
Console.WriteLine(*ptr2);    // displaying the value
Console.WriteLine((int)ptr1); // displaying the address
Console.WriteLine((int)ptr2); // displaying the address
}
}
}
class Example
{
// main method
public static void Main()
{
Demo d = new Demo();
d.Method();
}
}
}

Il existe différentes manières d'exécuter des instructions non sécurisées, comme un modificateur, un constructeur, etc. Dans l'exemple ci-dessus, un groupe d'instructions est marqué comme non sécurisé. Dans le code ci-dessus, il y a deux variables a et b avec respectivement les valeurs 40 et 20 et les pointeurs contiennent leurs adresses. Console.WriteLine() est utilisé pour afficher les valeurs et adresses des variables.

Sortie :

Pointeurs en C# – Exemple n°2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Pointers
{
class Demo
{
public unsafe void Method()
{
int a = 50;
int b = 20;
int* ptr1 = &a;
int* ptr2 = &b;
Console.WriteLine(*ptr1);       // displaying the value
Console.WriteLine(*ptr2);       // displaying the value
Console.WriteLine((int)ptr1);   // displaying the address
Console.WriteLine((int)ptr2);   // displaying the address
}
}
class Example
{
// main method
public static void Main()
{
Demo d = new Demo();
d.Method();
}
}
}

Dans l'exemple ci-dessus, unsafe est utilisé avec la méthode qui a deux variables a et b avec les valeurs 50 et 20 respectivement. Les pointeurs *ptr1 et *ptr2 pointent vers leurs adresses mémoire.

Sortie :

Pointeurs en C# – Exemple n°3

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Pointers
{
class Demo
{
public unsafe static void Main()
{
int[] array = { 10, 20, 30, 40, 50 };    // declaring array
fixed (int* ptr = array)                 // fixed for pinning the object
/* let us have array address in pointer */
for (int i = 0; i < 5; i++)
{
Console.WriteLine("Value of array[{0}]={1}", i, *(ptr + i));
Console.WriteLine("Address of array[{0}]={1}", i, (int)(ptr + i));
Console.ReadKey();
}
}
}
}

Dans le code ci-dessus, un tableau est défini qui se compose de cinq éléments et Console.WriteLine () est utilisé pour afficher la valeur des éléments du tableau et l'adresse des éléments du tableau. Il existe un concept en C# connu sous le nom d’épinglage d’un objet. Dans le code ci-dessus, une instruction fixe est utilisée pour l'épinglage d'un objet afin que le ramasse-miettes ne laisse pas l'objet se déplacer et ne l'épingle pas. Cela peut affecter l'efficacité de l'exécution.

Sortie :

Pointeurs en C# – Exemple n°4

using System;
namespace Pointers
{
// Struct employee
struct Employee
{
// members
// employee id and salary
public int empid;
public double salary;
// Constructor to initialize values
public Employee(int e, double s)
{
empid = e;
salary = s;
}
}; // end of struct
class Program
{
// Main Method
static void Main(string[] args)
{
// unsafe so as to use pointers
unsafe
{
// Declaring two employee Variables
Employee E1 = new Employee(798, 30000);
Employee E2 = new Employee(799, 31000);
// Declaring two employee pointers
// and initializing them with addresses
// of E1 and E2
Employee* E1_ptr = &E1;
Employee* E2_ptr = &E2;
// Displaying details of employees using pointers
// Using  the arrow ( -> ) operator
Console.WriteLine("Details of Employee 1");
Console.WriteLine("Employee Id: {0} Salary: {1}",
E1_ptr->empid, E1_ptr->salary);
Console.WriteLine("Details of Employee 2");
Console.WriteLine("Employee Id: {0} Salary: {1}",
E2_ptr->empid, E2_ptr->salary);
} // end unsafe
} // end main
} // end class
}

Dans l'exemple ci-dessus, la structure de l'employé avec l'identifiant et le salaire de l'employé des membres et paramètre le constructeur pour initialiser les valeurs. Les pointeurs pointent vers des structures qui contiennent un type valeur primitif au lieu de structures contenant un type référence. Dans la méthode principale, il existe deux variables d'employé et des pointeurs d'employé qui sont initialisés avec les adresses E1 et E2. Console.WriteLine() est utilisé pour afficher les détails de l'employé à l'aide de pointeurs.

Sortie :

Pointeurs en C# – Exemple n°5

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Pointers
{
class Demo
{
public static void Main()
{
unsafe
{
int* arr = stackalloc int[6];   // declaring array
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;
arr[5] = 60;
for (int i = 0; i < 6; i++)
{
Console.WriteLine($"Value at {i}: {arr[i]}");
Console.ReadKey();
}
}
}
}
}

Dans le code ci-dessus, le mot-clé stackalloc est utilisé, dans lequel la mémoire est allouée sur la pile. La mémoire exécutée sur le bloc de pile est créée lors de l'exécution de la méthode. stackalloc offre de meilleures performances et il n'est pas nécessaire d'épingler le tableau. C'est mieux que le tableau alloué au tas car il n'est pas nécessaire de le libérer car il se libère automatiquement au retour de la méthode.

Sortie :

Dans les pointeurs, les conversions sont de type implicite et explicite. Un type de conversion implicite est comme n’importe quel type de pointeur vers le type void* et null vers n’importe quel type de pointeur. En type explicite, les conversions s'effectuent de byte, sbyte, ushort, short, uint, int, ulong, long vers n'importe quel type de pointeur ou vice versa et d'un pointeur vers un autre pointeur.

Conclusion – Pointeurs en C#

Les pointeurs sont donc utilisés pour pointer les adresses mémoire et les exécuter avec un code d'instructions non sécurisé. Il n'est utilisé que dans un environnement non géré et n'est pas suivi par le ramasse-miettes. Les pointeurs sont utilisés dans une pile, une file d'attente, etc.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!