Úvod do ukazovateľov v jazyku C #
Ukazovatele sú definované ako premenná, ktorá obsahuje adresu pamäte inej premennej. Ukazovatele v jazyku C # sa používajú vždy, keď existuje vyhlásenie, ktoré nie je bezpečné a je označené nebezpečným kľúčovým slovom. Tieto typy príkazov nekontrolujú zberateľov odpadu a používajú premenné ukazovateľov.
Syntax: Ukazovatele možno deklarovať ako
type *var name;
int* a;
Tu * sa nazýva operátor referencie a a je premenná, ktorá obsahuje adresu typu int.
príklad
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
Ako fungujú ukazovatele v jazyku C #?
Nižšie sú uvedené príklady, ktoré ukazujú, ako to funguje v C #.
Ukazovatele v C # - Príklad č. 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();
)
)
)
Existujú rôzne spôsoby, ako vykonávať príkazy ako nebezpečné, napríklad Modifikátor, konštruktor atď. V uvedenom príklade je skupina príkazov označená ako nebezpečná. Vo vyššie uvedenom kóde sú dve premenné aab s hodnotami 40 a 20 a ukazovatele obsahujú ich adresy. Console.WriteLine () sa používa na zobrazenie hodnôt a adries premenných.
Výkon:
Ukazovatele v C # - Príklad č. 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();
)
)
)
Vo vyššie uvedenom príklade sa nebezpečný postup používa pri metóde, ktorá má dve premenné a a b s hodnotami 50 a 20. Ukazovatele * ptr1 a * ptr2 ukazujú na ich adresy v pamäti.
Výkon:
Ukazovatele v C # - Príklad č. 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();
)
)
)
)
Vo vyššie uvedenom kóde je definované pole, ktoré pozostáva z piatich prvkov a Console.WriteLine () sa používa na zobrazenie hodnoty prvkov poľa a adresy prvkov poľa. V C # je koncept, ktorý je známy ako pripnutie objektu. Vo vyššie uvedenom kóde sa na pripnutie objektu používa fixný príkaz, takže zberateľ odpadu nedovolí, aby sa objekt pohyboval a „pripinul“. Môže to ovplyvniť účinnosť runtime.
Výkon:
Ukazovatele v C # - Príklad č. 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
)
V uvedenom príklade zamestnanec štruktúruje s členmi zamestnanca id a plat a parametrizuje konštruktora na inicializáciu hodnôt. Ukazovatele ukazujú na štruktúry, ktoré obsahujú primitívny typ hodnoty namiesto štruktúr obsahujúcich referenčný typ. V hlavnej metóde existujú dve premenné zamestnancov a ukazovatele zamestnancov, ktoré sú inicializované adresami E1 a E2. Console.WriteLine () sa používa na zobrazenie podrobností zamestnanca pomocou ukazovateľov.
Výkon:
Ukazovatele v C # - Príklad č. 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();
)
)
)
)
)
Vo vyššie uvedenom kóde sa používa kľúčové slovo stackalloc, v ktorom je na zásobníku vyhradená pamäť. Pamäť vykonaná v bloku zásobníka sa vytvorí počas vykonávania metódy. stackalloc má lepšiu výkonnosť a pole nie je potrebné pripínať. Je to lepšie ako pole pridelené haldy, pretože ho nie je potrebné uvoľňovať, pretože sa automaticky vráti, keď sa metóda vráti.
Výkon:
V ukazovateľoch sú konverzie implicitného a explicitného typu. Implicitný typ konverzie je ako akýkoľvek typ ukazovateľa na neplatný * typ a nulový na akýkoľvek typ ukazovateľa. V explicitnom type sú konverzie z bajtov, sbyte, ushortov, krátkych, uintových, int, ulongových, dlhých na akýkoľvek typ ukazovateľa alebo naopak a jedného ukazovateľa na iný ukazovateľ.
Záver - Ukazovatele v jazyku C #
Ukazovatele sa teda používajú na nasmerovanie adries pamäte a na ich vykonanie s nebezpečným kódom príkazov. Používa sa iba v nespravovanom prostredí a nesleduje ho zberateľ odpadu. Ukazovatele sa používajú v zásobníku, fronte atď.
Odporúčané články
Toto je sprievodca ukazovateľmi v jazyku C #. Tu diskutujeme Úvod a ako pracuje ukazovateľ v C # spolu s rôznymi príkladmi. Viac informácií nájdete aj v nasledujúcich článkoch
- Použitie C #
- Ukazovatele v jazyku C ++
- C # vs výkon Java
- Čo je C?