Void-Zeiger in C:Warum Sie sie in Ihrem Programmiererlebnis brauchen

In Programmiersprachen machen bestimmte Konzepte das Codieren so viel einfacher. Beispielsweise bestimmt der void-Zeiger den spezifischen Datentyp aus den Eingaben eines Endbenutzers in der Programmiersprache C. Das bringt uns dazu, void-Zeiger in C zu diskutieren.

Void-Zeiger haben wie andere relevante Funktionen für ihre Flexibilität. Wenn Sie jedoch beim Codieren Zeit sparen möchten, ist Ihre Go-to-Pointer-Funktion ein Void-Pointer. Mit diesem Zeiger können Sie einen anderen Objekttyp gleichzeitig speichern und abrufen. Außerdem erfahren Sie alles über die Codierungstechniken mit void-Zeigern in C.

(Bild einer Programmiersprache)

1. Was sind Void-Zeiger in C？

Im Allgemeinen sind void-Zeiger Zeiger ohne zugehörigen Datentyp. Mit anderen Worten, sie sind wie leere Behälter. Diese Funktion ermöglicht es ihnen, Adressen eines Variablentyps mit unbekanntem Datentyp zu speichern.

Mit der void-Zeigerfunktion von C können Sie sie in andere Datentypen umwandeln, was eine einfache Speicherzuweisung ermöglicht. Anschließend ermöglicht dies flexible Funktionen wie Bytes in der Speicherallokation. Darüber hinaus helfen void-Zeiger in C bei der Ausführung generischer Funktionen.

(Ein einfaches „Hello World“-Programm in der Programmiersprache C)

https://commons.m.wikimedia.org/wiki/File:C_Hello_World_Program.png

2. Wie funktioniert Void Pointer in C?

Insgesamt ist die Zeigerfunktion für die Programmierung unerlässlich. Zumindest sehen wir seine Bedeutung in der Adressverwaltung und Speicherzuweisung.

Es gibt zwei verschiedene Zeigertypen; generische Zeiger und void-Zeiger. Unser Fokus liegt jedoch auf void-Zeigern und wie sie in C funktionieren.

Um einen void-Zeiger in C zu haben, müssen Sie nur eine Information mit dem Schlüsselwort „void“ deklarieren.

Insgesamt spielen Referenzierung und Dereferenzierung eine Rolle im Allzweck-Zeigerkonzept. Dereferenzierung ist in diesem Fall, wenn Sie einen Wert erhalten, der in der Zeigervariable gespeichert ist.

Wenn also ein Zeigerwert nicht mit den verfügbaren Datentypen verknüpft ist, haben Sie Typumwandlung als Option.

Beachten Sie jedoch, dass void-Zeiger keinerlei arithmetische Operationen unterstützen. Stattdessen verwenden wir den Indirektionsoperator „*“. Aus diesem Grund ist eine Typumwandlung erforderlich, wenn kein zugeordneter Datentyp vorhanden ist. Die Typumwandlung bezieht sich daher auf den neben dem void-Zeiger deklarierten Datentyp. Andernfalls zeigt das Ausführen des Programms einen Compiler-Fehler an.

Die Void-Größe ähnelt einem Zeichenzeiger in C. Das Größenobjekt variiert je nach Zeigerplattform.

Diese Speicherverwaltungsfunktionen sind malloc() und calloc(). Im Gegenzug helfen diese Funktionen dabei, Speicher des benötigten Datentyps zuzuweisen. In gewisser Weise verwendet die Speicherzuweisung ein Format, das es dem Funktionszeiger ermöglicht, andere Funktionen zu verbessern.

(Eine bildliche Darstellung, wie Zeiger in C funktionieren).

https://commons.m.wikimedia.org/wiki/File:C_pointer_3.svg

3. Syntax des Void-Zeigers

Normalerweise ist es am besten, die richtige Syntax zum Importieren von Programmierfunktionen zu verwenden. Daher lautet die Syntax eines void-Zeigers in C:

Void *Zeigername;

Wobei „void“ das Schlüsselwort des Zeigertyps ist. Wir haben also den Namen des Zeigers, auf den wir zeigen, und geben eine Adresszuordnung an.

Nehmen wir das folgende Beispiel:

intb =6

char c ='z';

In einem Fall, in dem wir eine void-Zeigervariable einschließen, haben wir daher:

Nichtig *p =&b; // void pointer weist zu und hält int 'b' als Adresse der Ganzzahl.

P =&c; // void-Zeiger enthält auch die Adresse von char 'c'.

Lassen Sie uns weiter gehen und einige Syntaxbeispiele hervorheben:

int i=6; // Initialisierung der Integer-Variablen.

int * p; // Integer-Zeiger-Deklaration.

ungültig *ptr; // ungültige Zeigerdeklaration.

float *fp; // Floating-Pointer-Deklaration.

p=fp; // ungültiger Zeiger.

ptr=p; // gültiger Zeiger.

fp=&i; // ungültiger Zeiger.

ptr=&i; // gültiger Zeiger.

ptr=fp; // gültiger Zeiger.

4. Einige Beispiele für Void-Zeiger in C mit Beispielcodes

Als nächstes sehen wir uns ein Beispiel für void-Zeigerargumente im folgenden Code-Snippet an:

Beispielcode Nr. 1

Im ersten unserer Codebeispiele zeigen wir, wie man die Funktion malloc() verwendet, also:

#include

#include

int main()

{

int a=90;

int *x =(int*)malloc(sizeof(int));

x=&a;

printf(“gezeigter Wert durch x-Zeiger :%d”,*x);

gibt 0 zurück;

}

Ausgabe

Beispielcode Nr. 2

In diesem nächsten Code zeigen wir das Typecasting-Konzept.

#include

int main()

{

void *ptr =NULL; //void Zeigervariable

int *p =NULL;// ganzzahlige Zeigervariable

char *cp =NULL;//Zeichenzeigervariable

float *fp =NULL;//float Zeigervariable

//Zeigergröße ungültig machen

printf("void pointer size =%d\n\n",sizeof(ptr));

//Integer-Zeigergröße

printf("ganzzahlige Zeigergröße =%d\n\n",sizeof(p));

//Größe des Zeichenzeigers

printf("Zeichenzeigergröße =%d\n\n",sizeof(cp));

//Float-Zeigergröße

printf(“float pointer size =%d\n\n”,sizeof(fp));

gibt 0 zurück;

}

Ausgabe

Ansonsten siehe den beigefügten Videolink unten zu ungültigen Zeigercodes in der C-Programmierung.

https://youtu.be/-503stjWLhc

5. Verwendung des void-Zeigers

Bei weitem hat der void-Zeiger eine große Relevanz in der C-Sprachprogrammierung.

• Sie helfen, auf Variablen eines beliebigen Datentyps zu zeigen.

Zum besseren Verständnis sehen Sie sich das Codebeispiel unten an. Einige davon sind:

#include

void main()

{

int num=10;//Initialisiert eine normale Variable

void *ptr;//Deklariert den void-Zeiger

ptr=#//Leitet den Ptr-Zeiger auf num

printf(“Der Wert der Integer-Variable ist =%d”,*ptr );

}

Das Ausführen dieses Codes führt jedoch zu einem Kompilierzeitfehler. Wenn Sie Typumwandlung für denselben Code verwenden, um den Zeiger zu dereferenzieren, erhalten Sie die gewünschte Ausgabe, also:

#include

void main()

{

int num=10;//Initialisiert eine normale Variable

void *ptr;//Deklariert den void-Zeiger

ptr=#//Leitet den Ptr-Zeiger auf num

printf(“Der Integer-Variablenwert ist %d”, *(int*)ptr );// Dereferenzierung mit Typecasting

}

Der ganzzahlige Variablenwert ist 10.

Daher können wir durch Typumwandlung void-Zeiger dereferenzieren.

Während also Zeigerarithmetik mit void-Zeigern ungültig ist, hilft Typumwandlung, dieses Problem zu lösen. Die Ausgabe wird:

(Void-Zeiger erleichtern die Codierung, indem sie die Position von Datenvariablen preisgeben)

• Bei calloc() und malloc() hilft der void-Zeiger dabei, Speicherplatz für alle Datentypen zuzuweisen.

Sehen Sie sich zur Veranschaulichung den folgenden Code an:

int main(void)

{

// Beachten Sie, dass die Funktion malloc() void * zurückgibt

// Anschließend Typumwandlung in einen beliebigen Datentyp wie char *, int *, …

int *x =malloc(sizeof(int) * n);

}

Beachten Sie, dass das obige Programm nur in C kompiliert wird.

• Zu guter Letzt hilft die Zeigervariable void bei der Implementierung generischer Funktionen in C.

Schlussfolgerung

Die Leerzeigerfunktion ist im Allgemeinen ein wesentliches Programmierwerkzeug. Programmierer finden es nützlich, weil ihm keine Datentypen zugeordnet sind. Zumindest beseitigt es die Verwirrung von Zeigern, die verschiedene Werte und Datenklassen aufeinander richten. Daher reduzieren void-Zeiger übermäßiges Type-Casting. Es unterstützt auch generische Zeigertypen von Daten. Daher ist es auch ein generischer Compiler.

Sie haben eine vollständige Anleitung zum Arbeiten mit void-Zeigern in c. Wenn Sie jedoch Fragen haben oder andere Programmierressourcen benötigen, steht Ihnen unsere Kontaktseite jederzeit zur Verfügung.