C# Zeiger

In C#werden Zeiger für ungewöhnliche und fortschrittliche Programme zugewiesen. Sie werden normalerweise bei der Interaktion mit dem COM -Framework verwendet. Zeiger werden in C# nur in begrenztem Umfang unterstützt. Zeigertypen werden im Gegensatz zu Referenztypen nicht vom Standardmüllsammlungsprozess überwacht. Zeiger können nur auf nicht verwaltete Typen hinweisen, die alle grundlegenden Enumentypen, Datentypen, andere Zeigertypen und Strukturen enthalten, die nur nicht verwaltete Typen enthalten. Der Artikel wird Ihnen über C# Zeiger angemessen demonstrieren.

Was sind Zeiger in C# in Ubuntu 20.04?

Zeiger werden verwendet, um den Speicher dynamisch zuzuweisen. Wir können sagen, dass ein Zeiger eine Variable ist, die die Adresse eines Speicherorts enthält. Es gibt zwei Teile für jede in einem Programm angegebene Variable:

1. Variable Adresse.
2. Variabler Wert gespeichert.

Wenn eine Erklärung in C# mit dem unsicheren Schlüsselwort als unsicher erklärt wird, werden Zeiger verwendet. Diese Aussagen, die Zeigervariablen verwenden, werden nicht von Müllsammlern gesteuert.

Zeigererklärung in C# in Ubuntu 20 machen.04

Das nachfolgende Skript ist die allgemeine Syntax, wie ein Zeigertyp deklariert wird:

Typ *variable_name;
int* p;

Der Dereferenzoperator wird durch das Sternchensymbol (*) bezeichnet. Der Wert aus der Adresse, auf die sich auf Zeiger referenzieren. Deklariert "P", eine Zeigervariable, die die Adresse eines INT -Typs trägt. Beachten Sie, dass bei einer Funktion des Codeblocks mit dem unsicheren Modifikator C# ermöglicht werden, Zeigervariablen zu verwenden. Ein Codeblock, bei dem eine Zeigervariable deklariert wird. In Ubuntu 20.04, wir müssen einen unsicheren Code wie diesen kompilieren: CS /unsicherer Dateiname.CS

Wie man Zeiger in C# in Ubuntu 20 verwendet.04

Das Schlüsselwort unsicher kann auf viele Arten verwendet werden. Es kann verwendet werden, um eine Methode, Eigenschaft, Konstruktor usw. zu ändern. Betrachten Sie die folgenden Beispiele:

Beispiel Nr. 1: Verwenden von Zeigern für die Deklaration in C # in Ubuntu 20.04

Die folgende Abbildung zeigt, wie eine Zeigervariable deklariert und verwendet wird. Hier haben wir den unsicheren Modifikator verwendet. Das Zeichen * wird verwendet, um Zeiger implizit zu deklarieren, wie im angegebenen Beispiel:

Der Code beginnt mit dem Importieren der Verwendungs- und Namespace -Dateien. Die Namespace -Datei hat den Namen "CSHARPPOINTERS" zugewiesen. Die Namespace -Datei hat einen Block, in dem wir eine Klasse „Programm1“ definiert haben. In der Klasse „Programm1“ werden mit der Hauptfunktion unsichere Schlüsselwörter verwendet. Mit dem unsicheren Schlüsselwort können wir unsichere Codes nur in C# verwenden. Dann haben wir in der unsicheren Hauptfunktion zwei Variablen deklariert. Der ersten Variablen wird ein Name "Wert" zugewiesen und setzt ihren Typ auf int int. Der Variable "Wert" ist ein ganzzahliger Wert. Die zweite Variable wird als „V“ vom Typ int mit dem Sternchen (*) -Symbol dargestellt, sodass es eine Zeigervariable des Typ -Integers ist. In der Zeigervariablen wird der Adressoperator (&) mit der Variablen "Wert" verwendet. Als Zeiger wird die Adresse des Wertes zurückgegeben. In der Writeline -Anweisung wird der Wert und die Adresse der angegebenen Variablen gedruckt.

Wir haben die folgende Ausgabe aus der obigen Codeausführung erhalten. Der Wert und die Adresse sind im Bild angezeigt.

Beispiel Nr. 2: Verwenden von Zeigern zum Zugriff auf Arrays in C # in Ubuntu 20.04

Ein Array ist eine Reihe von Daten derselben Art, die nur durch ihre Speicherordnung unterschieden werden. Im folgenden C# -Programm werden auf Arrays mit Zeigernotationen zugegriffen.

Der Code wird demonstriert, wo wir die Klasse in der Namespace -Datei "Pointerprogramm" definiert haben. Die Klasse hat einen Namen „Programm2“ zugewiesen und wir haben die Hauptfunktion mit einem unsicheren Modifikator bezeichnet. In der unsicheren Hauptfunktion haben wir ein INT-Typ-Referenzarray als "MyArray" erstellt, als wir ein Int-Typ-Referenzarray erstellt haben, als „MyArray“. Wir haben fünf verschiedene Werte in einem Array gespeichert. Dann haben wir eine Variable „PTR“ mit Zeigernotation erstellt. Die Zeigervariable hat ein Array gespeichert und wir haben die Zeigervariable mit dem Schlüsselwort "Behoben" festgehalten. Das Schlüsselwort "behoben" begrenzt die Variable des Arrays auf eine bestimmte Speicherzuweisung. Die Schreibeline -Anweisung wird verwendet, um die Speicheradresse und den Datentyp -Wert des Arrays anzuzeigen.

Wie Sie sehen können, wird jedes Element im Array sowie in der Adresse in der Ausgabe des obigen Code angezeigt.

Beispiel 3: Verwenden von Zeigern in Strukturen in C # in Ubuntu 20.04

In C#sind Werttypen die einzigen Komponenten von Strukturen. Zeiger werden nur in Strukturen verwendet, bei denen die primären Mitglieder alle Werttypen sind. Zeiger werden verwendet, um im folgenden Programm in C# auf Strukturmitglieder zugreifen zu können.

Der obige Code hat eine als „Mitarbeiter“ definierte Struktur und in der Struktur haben wir seine Mitglieder "empid" von Typ int und "Empsalary" des Typ -Eigentums doppelt festgelegt. Wir haben auch den Konstruktor für die Struktur „Mitarbeiter“ aufgebaut, um Werte für „Empid“ und „Empsalary“ als „X“ und „Y“ zu initialisieren. Dann haben wir eine Klasse „Programm3“ erstellt, die die Hauptfunktion hat. In der Hauptfunktion haben wir eine unsichere Etikett. Die Werte werden für die Mitglieder "empid" und "empsalary" im Objekt "E1" festgelegt. Der Zeiger wird für die Struktur "Mitarbeiter" als "e1_ptr" erstellt und initialisiert sie mit der Adresse von "E1".

Die Schreiblinie -Anweisung wird verwendet, um die angegebenen Struktur „Mitarbeiter“ -Details anzuzeigen. Wir haben einen Pfeilbetreiber mit den Zeigern verwendet, die auf die Variablen und Methoden der angegebenen Struktur zugegriffen haben.

Die obige Programmausführung hat die folgende Ausgabe auf dem Terminalbildschirm angezeigt.

Beispiel Nr. 4: Verwenden von Zeigern in Methoden in C # in Ubuntu 20.04

Ein Zeiger kann auch mit den Methoden zurückgegeben werden. Das unten gezeigte Beispiel hat die Zeiger als Parameter an eine Methode übergeben.

Wir haben eine Klasse in der Namespace -Datei als „Programm4“ definiert. Die Klasse hat eine Hauptfunktion als „Methode“, bei der wir das Etikett „unsicher“ verwendet haben. Wir haben im unsicheren Block eine variable "A1" und "A2" deklariert. Diese Variablen werden mit den Ganzzahlwerten initialisiert. Wir haben zwei Zeiger als "ptr1" und "ptr2" vom Typ int erstellt. Jetzt werden diese Zeiger als Integer -Zeigervariablen bezeichnet. Wir haben diese Zeiger die Adresse der Variablen „A1“ und „A2“ gegeben. Die Writeline -Methode wird aufgerufen, mit der der Wert und die Adresse der angegebenen Variablen angezeigt werden. Dann haben wir eine andere Klasse "Demo", in der wir ein Objekt "P" für die Klasse "Program4" deklarieren müssen. Die „Methode“ wird in dieser Klasse aufgerufen, um auf den Wert und die Adresse seines Mitglieds in der „Demo“ -Klasse zuzugreifen.

Wir erhalten die nachfolgende Ausgabe auf die Konsole, nachdem wir den obigen Code erstellt haben.

Abschluss

Wir sind am Ende des Artikels gekommen, indem wir feststellen, dass Zeiger, die die Speicheradresse anzeigen. Der unsichere Code ist erforderlich, da der Müllsammler in einer nicht verwalteten Umgebung keine Speicherorte aufrechterhalten. Wir haben gelernt, wie sich Zeiger in Methoden, Strukturen und Zugriff auf das Array von Elementen durch die verschiedenen Abbildungen verwenden.