Introduzione ai puntatori in C #
I puntatori sono definiti come una variabile che contiene l'indirizzo di memoria di un'altra variabile. I puntatori in C # vengono utilizzati ogni volta che esiste un'istruzione non sicura ed è contrassegnata da una parola chiave non sicura. Questi tipi di istruzioni non hanno il controllo dei garbage collector e utilizzano variabili puntatore.
Sintassi: i puntatori possono essere dichiarati come
type *var name;
int* a;
Qui * viene chiamato un operatore di riferimento e a è la variabile che contiene l'indirizzo di tipo int.
Esempio
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
Come funzionano i puntatori in C #?
Di seguito sono riportati gli esempi che mostrano come funziona in C #.
Puntatori in C # - Esempio 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();
)
)
)
Esistono diversi modi per eseguire le istruzioni come non sicure come un modificatore, un costruttore, ecc. Nell'esempio precedente, un gruppo di istruzioni è contrassegnato come non sicuro. Nel codice sopra, ci sono due variabili aeb con i valori 40 e 20 rispettivamente e i puntatori contengono i loro indirizzi. Console.WriteLine () viene utilizzato per visualizzare i valori e gli indirizzi delle variabili.
Produzione:
Puntatori in C # - Esempio # 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();
)
)
)
Nell'esempio sopra, unsafe è usato con il metodo che ha due variabili a e b con valori 50 e 20 rispettivamente. I puntatori * ptr1 e * ptr2 puntano ai loro indirizzi di memoria.
Produzione:
Puntatori in C # - Esempio # 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();
)
)
)
)
Nel codice sopra, viene definito un array composto da cinque elementi e Console.WriteLine () viene utilizzato per visualizzare il valore degli elementi dell'array e l'indirizzo degli elementi dell'array. C'è un concetto in C # che è noto come Pinning di un oggetto. Nel codice precedente, viene utilizzata un'istruzione fissa per bloccare gli oggetti in modo che il Garbage Collector non consenta all'oggetto di spostarsi e "bloccarlo". Può influire sull'efficienza di runtime.
Produzione:
Puntatori in C # - Esempio 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
)
Nell'esempio precedente, la struttura dei dipendenti con ID dipendente dipendente e stipendio e parametrizza il costruttore per inizializzare i valori. I puntatori puntano a strutture che contengono un tipo di valore primitivo anziché a strutture che contengono un tipo di riferimento. Nel metodo principale, ci sono due variabili e puntatori dipendenti che sono inizializzati con gli indirizzi E1 ed E2. Console.WriteLine () viene utilizzato per visualizzare i dettagli dell'impiegato utilizzando i puntatori.
Produzione:
Puntatori in C # - Esempio # 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();
)
)
)
)
)
Nel codice sopra, viene utilizzata la parola chiave stackalloc, in cui la memoria viene allocata nello stack. La memoria eseguita sul blocco di stack viene creata durante l'esecuzione del metodo. stackalloc ha prestazioni migliori e non è necessario aggiungere l'array. È migliore dell'array allocato in heap in quanto non è necessario liberarlo perché viene liberato automaticamente quando il metodo ritorna.
Produzione:
Nei puntatori, le conversioni sono di tipo implicito ed esplicito. Un tipo implicito di conversione è come qualsiasi tipo di puntatore per annullare il tipo * e null per qualsiasi tipo di puntatore. Nel tipo esplicito, le conversioni sono da byte, sbyte, ushort, short, uint, int, ulong, long a qualsiasi tipo di puntatore o viceversa e da un puntatore a un altro puntatore.
Conclusione - Puntatori in C #
Quindi i puntatori vengono utilizzati per puntare gli indirizzi di memoria ed eseguirli con un codice di istruzioni non sicuro. Viene utilizzato solo in un ambiente non gestito e non viene monitorato dal Garbage Collector. I puntatori vengono utilizzati in uno stack, in una coda, ecc.
Articoli consigliati
Questa è una guida ai puntatori in C #. Qui discutiamo Introduzione e come funziona il puntatore in C # insieme a vari esempi. Puoi anche consultare i seguenti articoli per saperne di più-
- Usi di C #
- Puntatori in C ++
- C # vs prestazioni Java
- Che cos'è C?