Introduction aux 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'une instruction n'est pas sûre et est marquée par un mot clé non sécurisé. Ces types d'instructions ne contrôlent pas les récupérateurs de place 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érence 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 les pointeurs fonctionnent-ils en C #?
Voici des exemples qui montrent comment cela fonctionne en C #.
Pointeurs en C # - Exemple # 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 façons d'exécuter des instructions comme 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 les adresses des variables.
Production:
Pointeurs en C # - Exemple # 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.
Production:
Pointeurs en C # - Exemple # 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 # qui est connu comme l'épinglage d'un objet. Dans le code ci-dessus, une instruction fixe est utilisée pour l'épinglage d'objet afin que le garbage collector ne laisse pas l'objet se déplacer et le «pin». Cela peut affecter l'efficacité d'exécution.
Production:
Pointeurs en C # - Exemple # 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, structure de l'employé avec l'ID et le salaire de l'employé et paramétrez le constructeur pour initialiser les valeurs. Les pointeurs pointent vers des structures qui contiennent un type de valeur primitif au lieu de structures contenant un type de référence. Dans la méthode principale, il y a 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.
Production:
Pointeurs en C # - Exemple # 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 la baie. Il est meilleur que le tableau alloué par segment de mémoire car il n'est pas nécessaire de le libérer car il se libère automatiquement lorsque la méthode revient.
Production:
Dans les pointeurs, les conversions sont de type implicite et explicite. Un type de conversion implicite est comme tout type de pointeur vers le type void * et null vers tout type de pointeur. Dans le type explicite, les conversions sont d'octet, sbyte, ushort, short, uint, int, ulong, long vers n'importe quel type de pointeur ou vice versa et 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 garbage collector. Les pointeurs sont utilisés dans une pile, une file d'attente, etc.
Articles recommandés
Ceci est un guide des pointeurs en C #. Ici, nous discutons Introduction et comment fonctionne le pointeur en C # avec divers exemples. Vous pouvez également consulter les articles suivants pour en savoir plus-
- Utilisations de C #
- Pointeurs en C ++
- Performances C # vs Java
- Qu'est-ce que C?