Inleiding tot aanwijzers in C #
Aanwijzers worden gedefinieerd als een variabele die het geheugenadres van een andere variabele bevat. Aanwijzers in C # worden gebruikt wanneer er een verklaring is die onveilig is en wordt gemarkeerd met een onveilig trefwoord. Dat soort uitspraken hebben geen controle over afvalverzamelaars en gebruiken pointervariabelen.
Syntaxis: pointers kunnen worden aangegeven als
type *var name;
int* a;
Hier * wordt een verwijzingsoperator genoemd en is a de variabele die het adres van het type int bevat.
Voorbeeld
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
Hoe werkt Pointers in C #?
Hieronder staan de voorbeelden die laten zien hoe het werkt in C #.
Aanwijzers in C # - Voorbeeld # 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();
)
)
)
Er zijn verschillende manieren om instructies als onveilig uit te voeren, zoals een Modifier, constructor, enz. In het bovenstaande voorbeeld wordt een groep instructies gemarkeerd als onveilig. In de bovenstaande code zijn er twee variabelen a en b met respectievelijk waarden 40 en 20 en aanwijzers bevatten hun adressen. Console.WriteLine () wordt gebruikt om de waarden en adressen van de variabelen weer te geven.
Output:
Aanwijzers in C # - Voorbeeld # 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();
)
)
)
In het bovenstaande voorbeeld wordt onveilig gebruikt met de methode die twee variabelen a en b heeft met respectievelijk waarden 50 en 20. Aanwijzers * ptr1 en * ptr2 wijzen naar hun geheugenadressen.
Output:
Aanwijzers in C # - Voorbeeld # 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();
)
)
)
)
In de bovenstaande code is een array gedefinieerd die uit vijf elementen bestaat en wordt Console.WriteLine () gebruikt om de waarde van arrayelementen en het adres van de arrayelementen weer te geven. Er is een concept in C # dat bekend staat als het vastzetten van een object. In de bovenstaande code wordt een vaste instructie gebruikt voor het vastzetten van objecten, zodat de vuilnisman het object niet kan laten bewegen en vastzetten. Dit kan de runtime-efficiëntie beïnvloeden.
Output:
Aanwijzers in C # - Voorbeeld # 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
)
In het bovenstaande voorbeeld, werknemer struct met leden-werknemers-ID en salaris en parametreer constructor om de waarden te initialiseren. Aanwijzers wijzen naar structs die het type primitieve waarde bevatten in plaats van structs die het referentietype bevatten. In de hoofdmethode zijn er twee werknemersvariabelen en werknemersaanwijzers die worden geïnitialiseerd met adressen E1 en E2. Console.WriteLine () wordt gebruikt om de details weer te geven van de werknemer die pointers gebruikt.
Output:
Aanwijzers in C # - Voorbeeld # 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();
)
)
)
)
)
In de bovenstaande code wordt het stackalloc-sleutelwoord gebruikt, waarin geheugen op de stapel wordt toegewezen. Het geheugen dat op het stapelblok wordt uitgevoerd, wordt tijdens de uitvoering van de methode gemaakt. Stackalloc is beter in prestaties en het is niet nodig om de array vast te pinnen. Het is beter dan de heap-toegewezen array omdat het niet hoeft te worden bevrijd omdat het automatisch wordt vrijgegeven wanneer de methode terugkeert.
Output:
In aanwijzers zijn conversies van een impliciet en expliciet type. Een impliciet type conversie lijkt op elk type pointer naar het type void * en is nul voor elk pointertype. In expliciet type zijn conversies van byte, sbyte, ushort, kort, uint, int, ulong, lang naar elk type aanwijzer of vice versa en één aanwijzer naar een andere aanwijzer.
Conclusie - Pointers in C #
Dus pointers worden gebruikt om de geheugenadressen aan te wijzen en uit te voeren met een onveilige code of statements. Het wordt alleen gebruikt in een onbeheerde omgeving en wordt niet gevolgd door de vuilnisman. Aanwijzers worden gebruikt in een stapel, wachtrij, enz.
Aanbevolen artikelen
Dit is een gids voor Pointers in C #. Hier bespreken we Inleiding en hoe werkt pointer in C # samen met verschillende voorbeelden. U kunt ook de volgende artikelen bekijken voor meer informatie-
- Gebruik van C #
- Aanwijzers in C ++
- C # versus Java-prestaties
- Wat is C?