Einführung in Zeiger in C #
Zeiger werden als Variable definiert, die die Speicheradresse einer anderen Variablen enthält. Zeiger in C # werden immer dann verwendet, wenn eine Anweisung vorliegt, die unsicher ist und durch ein unsicheres Schlüsselwort gekennzeichnet ist. Diese Anweisungstypen haben keine Kontrolle über Garbage Collectors und verwenden Zeigervariablen.
Syntax: Zeiger können als deklariert werden
type *var name;
int* a;
Hier wird * als De-Referenz-Operator bezeichnet und a ist die Variable, die die Adresse vom Typ int enthält.
Beispiel
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
Wie funktionieren Zeiger in C #?
Unten sehen Sie die Beispiele, die zeigen, wie es in C # funktioniert.
Zeiger in C # - Beispiel # 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();
)
)
)
Es gibt verschiedene Möglichkeiten, Anweisungen als unsicher auszuführen, z. B. einen Modifikator, einen Konstruktor usw. Im obigen Beispiel wird eine Gruppe von Anweisungen als unsicher markiert. Im obigen Code gibt es zwei Variablen a und b mit den Werten 40 bzw. 20, und Zeiger enthalten ihre Adressen. Console.WriteLine () wird verwendet, um die Werte und Adressen der Variablen anzuzeigen.
Ausgabe:
Zeiger in C # - Beispiel # 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();
)
)
)
Im obigen Beispiel wird unsicher mit der Methode verwendet, die zwei Variablen a und b mit den Werten 50 bzw. 20 hat. Die Zeiger * ptr1 und * ptr2 zeigen auf ihre Speicheradressen.
Ausgabe:
Zeiger in C # - Beispiel # 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();
)
)
)
)
Im obigen Code ist ein Array definiert, das aus fünf Elementen besteht. Console.WriteLine () wird verwendet, um den Wert von Array-Elementen und die Adresse der Array-Elemente anzuzeigen. In C # gibt es ein Konzept, das als Pinning eines Objekts bezeichnet wird. Im obigen Code wird eine feste Anweisung zum Fixieren von Objekten verwendet, damit der Garbage Collector das Objekt nicht bewegen und "fixieren" kann. Dies kann die Laufzeiteffizienz beeinträchtigen.
Ausgabe:
Zeiger in C # - Beispiel # 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
)
Im obigen Beispiel wird die Mitarbeiterstruktur mit der Mitarbeiter-ID und dem Gehalt des Mitglieds erstellt und der Konstruktor parametrisiert, um die Werte zu initialisieren. Zeiger zeigen auf Strukturen, die einen primitiven Wertetyp enthalten, anstatt auf Strukturen, die einen Referenztyp enthalten. Bei der Hauptmethode gibt es zwei Angestelltenvariablen und Angestelltenzeiger, die mit den Adressen E1 und E2 initialisiert werden. Console.WriteLine () wird verwendet, um die Details des Mitarbeiters mithilfe von Zeigern anzuzeigen.
Ausgabe:
Zeiger in C # - Beispiel # 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();
)
)
)
)
)
Im obigen Code wird das Schlüsselwort stackalloc verwendet, in dem der Speicher auf dem Stapel zugeordnet ist. Der auf dem Stapelblock ausgeführte Speicher wird während der Ausführung der Methode erstellt. stackalloc hat eine bessere Leistung und es ist nicht erforderlich, das Array zu pinnen. Es ist besser als das Heap-zugewiesene Array, da es nicht freigegeben werden muss, da es automatisch freigegeben wird, wenn die Methode zurückkehrt.
Ausgabe:
In Zeigern handelt es sich um implizite und explizite Konvertierungen. Eine implizite Art der Konvertierung ist wie jeder Zeigertyp zu void * und null zu jedem Zeigertyp. Beim expliziten Typ erfolgen die Konvertierungen von Byte, Byte, ushort, short, uint, int, ulong, long zu einem beliebigen Zeigertyp oder umgekehrt und ein Zeiger zu einem anderen Zeiger.
Fazit - Zeiger in C #
Zeiger werden also verwendet, um auf die Speicheradressen zu verweisen und sie mit einem unsicheren Anweisungscode auszuführen. Es wird nur in einer nicht verwalteten Umgebung verwendet und vom Garbage Collector nicht verfolgt. Zeiger werden in einem Stapel, einer Warteschlange usw. verwendet.
Empfohlene Artikel
Dies ist eine Anleitung zu Zeigern in C #. Hier diskutieren wir die Einführung und wie Zeiger in C # funktionieren, zusammen mit verschiedenen Beispielen. Sie können sich auch die folgenden Artikel ansehen, um mehr zu erfahren.
- Verwendung von C #
- Zeiger in C ++
- C # vs Java-Leistung
- Was ist C?