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. Daher kommen wir dazu, leere Zeiger in C zu diskutieren.
Wie andere haben Void-Zeiger relevante Funktionen für ihre Flexibilität. Wenn Sie jedoch beim Codieren Zeit sparen möchten, ist Ihre Go-to-Pointer-Funktion ein void-Zeiger. Mit diesem Zeiger können Sie einen anderen Objekttyp gleichzeitig speichern und abrufen. Anschließend erfahren Sie alles über die Codierungstechniken mit Void-Zeigern in C.
(Abbildung einer Programmiersprache)
1. Leere Zeiger in C:Was sind Void Pointers 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 einer Typvariablen unbekannten Datentyps zu speichern.
Mit der void-Zeigerfunktion von C können Sie sie in andere Datentypen umwandeln und so eine einfache Speicherzuweisung ermöglichen. Anschließend ermöglicht dies flexible Funktionen wie Bytes in der Speicherzuordnung. Darüber hinaus helfen Void-Zeiger in C bei der Ausführung generischer Funktionen.
(Ein einfaches „Hello World“ -Programm in der Programmiersprache C)
Quelle:
https://commons.m.wikimedia.org/wiki/File:C_Hello_World_Program.png
2. Leere Zeiger in C:Wie funktioniert Void Pointer in C?
Insgesamt ist die Zeigerfunktion essentiell für die Programmierung. Zumindest sehen wir seine Bedeutung bei der Verwaltung und Speicherzuweisung.
Es gibt zwei verschiedene Zeigertypen. generische Zeiger und leere 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. In diesem Fall wird die Dereferenzierung durchgeführt, wenn Sie einen in der Zeigervariablen gespeicherten Wert abrufen.
Wenn also kein Zeigerwert den verfügbaren Datentypen zugeordnet ist, haben Sie die Typumwandlung als Option.
Beachten Sie jedoch, dass void-Zeiger keinerlei arithmetische Operationen unterstützen. Stattdessen verwenden wir den Indirektionsoperator „*“. Aus diesem Grund wird es notwendig, in Ermangelung eines zugeordneten Datentyps typumwandert zu werden. Typecasting bezieht daher den deklarierten Datentyp neben den void-Zeiger. Andernfalls wird beim Ausführen des Programms ein Compilerfehler angezeigt.
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, Speicher des benötigten Datentyps zuzuweisen. In gewisser Weise verwendet die Speicherzuweisung ein Format, mit dem der Funktionszeiger andere Features verbessern kann.
(Eine bildliche Illustration der Funktionsweise von Zeigern in C).
Quelle:
https://commons.m.wikimedia.org/wiki/File:C_pointer_3.svg
3. Leere Zeiger in C:Syntax des Void-Zeigers
Normalerweise ist es am besten, die richtige Syntax zu verwenden, um eine beliebige Programmierfunktion zu importieren. Daher lautet die Syntax eines Void-Zeigers in C:
Ungültig *pointer_name;
Wobei „void“ das Schlüsselwort des Zeigertyps ist. Wir haben also den Namen des Zeigers, auf den wir zeigen, und geben eine Adresszuweisung an.
Nehmen wir das folgende Beispiel:
int b = 6
char c = ‚z‘;
Daher haben wir in einem Fall, in dem wir eine void-Zeigervariable einschließen, Folgendes:
Void *p = &b; // void Zeiger weist int ‚b‘ als Adresse der ganzen Zahl zu und hält sie.
P = &c; // void Pointer enthält auch char ‚c‘ Adresse.
Lassen Sie uns noch einige Syntaxbeispiele hervorheben:
int i=6; Initialisierung der ganzzahligen Variablen.
int *p; ganzzahlige Zeigerdeklaration.
void *ptr; void-Zeigerdeklaration.
float *fp; Schwebende Zeigerdeklaration.
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. Leere Zeiger in C:Einige Beispiele für Void-Zeiger in C mit Beispielcodes
Im folgenden Codeausschnitt sehen wir uns ein Beispiel für void-Zeigerargumente an:
Beispielcode #1
Im ersten unserer Codebeispiele zeigen wir, wie die malloc () -Funktion verwendet wird, und zwar folgendermaßen:
#include <stdio.h>
#include<malloc.h>
int main()
{
int a=90;
int *x = (int*)malloc(sizeof(int)) ;
x=&a;
printf(„spitzer Wert durch x Zeiger : %d“,*x);
Rückgabe 0;
}
Ausgabe
Beispielcode #2
In diesem nächsten Code zeigen wir das Typ-Casting-Konzept.
#include <stdio.h>
int main()
{
void *ptr = NULL; void-Zeigervariable
int *p = NULL;// ganzzahlige Zeigervariable
char *cp = NULL;//zeichen Zeigervariable
float *fp = NULL;//float Zeigervariable
Leere Zeigergröße
printf(„void pointer size = %d\n\n“,sizeof(ptr));
Größe des ganzzahligen Zeigers
printf(„integer pointer size = %d\n\n“,sizeof(p));
Zeichenzeigergröße
printf(„zeichenzeigergröße = %d\n\n“,sizeof(cp));
Größe des Float-Zeigers
printf(„float pointer size = %d\n\n“,sizeof(fp));
Rückgabe 0;
}
Ausgabe
Andernfalls sehen Sie den angehängten Videolink unten zu void-Zeigercodes in der C-Programmierung.
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 verweisen.
Zum besseren Verständnis finden Sie im folgenden Codebeispiel. Einige von ihnen sind:
#include<stdio.h>
void main()
{
int num=10;//Initialisiert eine normale Variable
void *ptr;//Deklariert den void-Zeiger
ptr=#//Leitet ptr-Zeiger auf num weiter
printf(„Der Wert der ganzzahligen Variablen ist= %d“,*ptr );
}
Das Ausführen dieses Codes führt jedoch zu einem Kompilierzeitfehler. Wenn Sie die Typumwandlung für denselben Code verwenden, um den Zeiger zu dereferenzieren, erhalten Sie die gewünschte Ausgabe, also:
#include<stdio.h>
void main()
{
int num=10;//Initialisiert eine normale Variable
void *ptr;//Deklariert den void-Zeiger
ptr=#//Leitet ptr-Zeiger auf num weiter
printf(„Der Ganzzahlvariablenwert ist %d“, *(int*)ptr );// Dereferencing mittels Typecasting
}
Der Ganzzahlvariablenwert ist 10.
Daher können wir durch Typumwandlung Void-Zeiger dereferenzieren.
Während also die Zeigerarithmetik mit leeren Zeigern ungültig ist, hilft die Typumwandlung, dieses Problem zu lösen. Die Ausgabe wird:
(Void-Zeiger erleichtern die Codierung, indem er die Position von Datenvariablen anzeigt))
Mit calloc() und malloc () hilft der void-Zeiger bei der Zuweisung des Speicherorts für alle Datentypen.
Zur Veranschaulichung sehen Sie sich den folgenden Code an:
int main(void)
{
Beachten Sie, dass die Funktion malloc() void * zurückgibt.
Anschließend wird der Typ in einen beliebigen Datentyp umgewandelt, z. B. char *, int *,…
int *x = malloc(sizeof(int) * n);
}
Bemerkenswert ist, dass das obige Programm nur in C kompiliert.
Zu guter Letzt hilft die void-Zeigervariable bei der Implementierung generischer Funktionen in C.
Schlussfolgerung
Die Void-Zeigerfunktion ist im Allgemeinen ein wesentliches Programmierwerkzeug. Programmierer finden es nützlich, da ihm keine Datentypen zugeordnet sind. Zumindest beseitigt es die Verwirrung von Zeigern, die verschiedene Werte und Datenklassen aufeinander richten. Daher reduzieren Void-Zeiger überschüssiges Type-Casting. Es unterstützt auch generische Zeigertypen von Daten. Daher ist es auch ein Compiler für generische Zwecke.
Sie haben eine vollständige Anleitung zum Arbeiten mit Void-Zeigern in c. Wenn Sie jedoch Anfragen haben oder andere Programmierressourcen benötigen, steht Ihnen unsere Kontaktseite jederzeit zur Verfügung.
