Introducere în pointeri în C #
Indicatoarele sunt definite ca o variabilă care conține adresa de memorie a altei variabile. Punctele din C # sunt utilizate ori de câte ori există o declarație care nu este sigură și este marcată de un cuvânt cheie nesigur. Aceste tipuri de declarații nu controlează colectoarele de gunoi și folosesc variabile pointer.
Sintaxă: indicatorii pot fi declarați ca
type *var name;
int* a;
Aici * se numește operator de de-referință și a este variabila care conține adresa de tip int.
Exemplu
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
Cum funcționează pointerii în C #?
Mai jos sunt exemplele care arată cum funcționează în C #.
Punctele în C # - Exemplul # 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();
)
)
)
Există diferite modalități de a executa instrucțiuni la fel de nesigure precum un modificator, constructor etc. În exemplul de mai sus, un grup de instrucțiuni sunt marcate ca nesigure. În codul de mai sus, există două variabile a și b cu valorile 40 și respectiv 20, iar indicatoarele conțin adresele lor. Console.WriteLine () este utilizat pentru a afișa valorile și adresele variabilelor.
ieşire:
Punctele în C # - Exemplul # 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();
)
)
)
În exemplul de mai sus, nesigur este utilizat cu metoda care are două variabile a și b cu valorile 50 și respectiv 20. Indicatorii * ptr1 și * ptr2 indică adresele de memorie ale acestora.
ieşire:
Punctele în C # - Exemplul # 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();
)
)
)
)
În codul de mai sus, este definit un tablou care este format din cinci elemente și Console.WriteLine () este utilizat pentru a afișa valoarea elementelor de matrice și adresa elementelor de matrice. Există un concept în C #, care este cunoscut sub numele de Pinning a unui obiect. În codul de mai sus, o instrucțiune fixă este folosită pentru fixarea obiectului, astfel încât colectorul de gunoi să nu lase obiectul să se miște și să-l „fixeze”. Poate afecta eficiența în timp de rulare.
ieşire:
Punctele în C # - Exemplul # 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
)
În exemplul de mai sus, structura angajatului cu membrii id și salariul angajaților și parametrize constructor pentru inițializarea valorilor. Pointerii indică structuri care conțin tip de valoare primitivă în loc de structuri care conțin tip de referință. În metoda principală, există două variabile angajați și indicatori angajați care sunt inițializate cu adresele E1 și E2. Console.WriteLine () este utilizat pentru a afișa detaliile angajatului folosind indicatoare.
ieşire:
Punctele în C # - Exemplul # 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();
)
)
)
)
)
În codul de mai sus, se utilizează cuvântul cheie stackalloc, în care memoria este alocată pe stivă. Memoria executată pe blocul de stivă este creată în timpul executării metodei. stackalloc are o performanță mai bună și nu este nevoie să fixați tabloul. Este mai bun decât tabloul alocat pentru heap, deoarece nu este nevoie să îl eliberați, deoarece se eliberează automat la întoarcerea metodei.
ieşire:
În pointeri, conversiile sunt de tip implicit și explicit. Un tip implicit de conversie este ca orice tip de pointer pentru tipul void * și nul pentru orice tip de pointer. În tip explicit, conversiile sunt de la byte, sbyte, ushort, short, uint, int, ulong, lung până la orice tip de pointer sau invers și un pointer la alt pointer.
Concluzie - Pointeri în C #
Prin urmare, indicatoarele sunt folosite pentru a puncta adresele de memorie și a le executa cu un cod nesigur de declarații. Se folosește doar într-un mediu neadministrat și nu este urmărit de colectorul de gunoi. Pointerii sunt folosiți într-o stivă, coadă etc.
Articole recomandate
Acesta este un ghid pentru indicatorii din C #. Aici discutăm Introducere și cum funcționează indicatorul în C # împreună cu diverse exemple. De asemenea, puteți consulta următoarele articole pentru a afla mai multe-
- Utilizări ale C #
- Punctele în C ++
- C # vs performanță Java
- Ce este C?