Void Pointers in C： Waarom u ze nodig hebt in uw codeerervaring

In programmeertalen maken bepaalde concepten het coderen zoveel gemakkelijker. De void-pointer bepaalt bijvoorbeeld het specifieke gegevenstype op basis van de invoer van een eindgebruiker in de programmeertaal C. Vandaar dat het ons ertoe brengt om lege punten in C te bespreken.

Net als andere hebben void pointers relevante functies vanwege hun flexibiliteit. Maar als u tijd wilt besparen bij het coderen, is uw go-to-aanwijzerfunctie een lege aanwijzer. Met deze aanwijzer kunt u tegelijkertijd een ander objecttype opslaan en ophalen. Verderop leer je alles over de coderingstechnieken met void pointers in C.

(Afbeelding van een programmeertaal)

1. Wat zijn lege wijzers in C？

Over het algemeen zijn void pointers aanwijzers zonder enig gerelateerd gegevenstype. Met andere woorden, ze zijn als lege containers. Met deze functie kunnen ze adressen bevatten van een typevariabele van een onbekend gegevenstype.

Met de void pointer-functie van C kunt u ze in andere gegevenstypen typen, waardoor u gemakkelijk geheugen kunt toewijzen. Dit maakt vervolgens flexibele functies mogelijk, zoals bytes in geheugentoewijzing. Bovendien helpen void-pointers in C bij het uitvoeren van generieke functies.

(Een eenvoudig "Hello World"-programma in programmeertaal C)

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

2. Hoe werkt Void Pointer in C?

Over het algemeen is de aanwijzerfunctie essentieel voor het programmeren. We zien in ieder geval het belang ervan in bij het aanpakken van beheer en geheugentoewijzing.

Er zijn twee verschillende soorten aanwijzers; generieke wijzers en lege wijzers. Onze focus ligt echter op void pointers en hoe ze werken in C.

Om een ​​void pointer in C te hebben, hoef je alleen maar een stukje informatie te declareren met het trefwoord 'void'.

Over het algemeen spelen referencing en dereferencing een rol in het algemene pointerconcept. Dereferentie is in dit geval wanneer u een waarde verkrijgt die is opgeslagen in de pointervariabele.

Dus als een pointerwaarde niet is gekoppeld aan de beschikbare gegevenstypen, hebt u typecasting als optie.

Merk echter op dat void pointers geen enkele rekenkundige bewerking ondersteunen. In plaats daarvan gebruiken we de indirecte operator "*." Om die reden wordt het noodzakelijk om te typecasten bij afwezigheid van een bijbehorend datatype. Typecasting relateert daarom het gegevenstype dat naast de lege aanwijzer is gedeclareerd. Anders geeft het uitvoeren van het programma een compilerfout weer.

De grootte van de lege ruimte is vergelijkbaar met een tekenaanwijzer in C. De grootte van het object varieert afhankelijk van het aanwijzerplatform.

Deze geheugenbeheerfuncties zijn malloc () en calloc (). In ruil daarvoor helpen deze functies bij het toewijzen van geheugen van het benodigde gegevenstype. In zekere zin gebruikt geheugentoewijzing een formaat waarmee de functieaanwijzer andere functies kan verbeteren.

(Een picturale illustratie van hoe aanwijzers werken in C).

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

3. Syntaxis van ongeldige aanwijzer

Meestal is het het beste om de juiste syntaxis te gebruiken om een ​​programmeerfunctie te importeren. Daarom is de syntaxis van een lege aanwijzer in C:

Void *pointer_name;

Waarbij "void" het sleutelwoord is van het type aanwijzer. We hebben dus de naam van de aanwijzer waarnaar we verwijzen en geven een adrestoewijzing.

Laten we het onderstaande voorbeeld nemen:

int b =6

char c ='z';

Daarom, in het geval dat we een void pointervariabele opnemen, hebben we:

Nietig *p =&b; // void pointer wijst int 'b' toe en houdt deze vast als adres van integer.

P =&c; // void pointer bevat ook char 'c' adres.

Laten we, om verder te gaan, enkele syntaxisvoorbeelden benadrukken:

int i=6; // initialisatie van integer variabele.

int *p; // declaratie van gehele aanwijzer.

ongeldig *ptr; // ongeldige aanwijzerverklaring.

zweven *fp; // declaratie met drijvende aanwijzer.

p=fp; // ongeldige aanwijzer.

ptr=p; // geldige aanwijzer.

fp=&i; // ongeldige aanwijzer.

ptr=&i; // geldige aanwijzer.

ptr=fp; // geldige aanwijzer.

4. Enkele voorbeelden van ongeldige aanwijzers in C met voorbeeldcodes

Verderop kijken we naar een voorbeeld van ongeldige aanwijzerargumenten in het onderstaande codefragment:

Voorbeeldcode #1

In de eerste van onze codevoorbeelden laten we zien hoe we de malloc ()-functie kunnen gebruiken, dus:

#include

#include

int main()

{

int a=90;

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

x=&a;

printf(“puntige waarde door x pointer:%d”,*x);

retourneer 0;

}

Uitgang

Voorbeeldcode #2

In deze volgende code laten we het type-casting-concept zien.

#include

int main()

{

ongeldig *ptr =NULL; //void pointer variabele

int *p =NULL;// integer pointervariabele

char *cp =NULL;//character pointer variabele

float *fp =NULL;//float pointer variabele

// ongeldige aanwijzergrootte

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

//integer pointergrootte

printf(“integer pointer size =%d\n\n”,sizeof(p));

//char pointergrootte

printf(“tekenaanwijzergrootte =%d\n\n”,sizeof(cp));

// grootte van zwevende aanwijzer

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

retourneer 0;

}

Uitvoer

Zie anders de bijgevoegde videolink hieronder over ongeldige aanwijzercodes in C-programmering.

https://youtu.be/-503stjWLhc

5. Gebruik van ongeldige aanwijzer

Verreweg de void pointer is enorm relevant in C-taalprogrammering.

• Ze helpen bij het verwijzen naar variabelen van elk gegevenstype.

Zie het codevoorbeeld hieronder voor een beter begrip. Sommigen van hen omvatten:

#include

void main()

{

int num=10;//Initialiseert een normale variabele

void *ptr;//Declareert de void pointer

ptr=#// Leidt Ptr-aanwijzer naar num

printf(“De waarde van integer variabele is=%d”,*ptr );

}

Het uitvoeren van deze code resulteert echter in een compileerfout. Als u typecasting op dezelfde code gebruikt om de verwijzing naar de aanwijzer te verwijderen, krijgt u de gewenste uitvoer, dus:

#include

void main()

{

int num=10;//Initialiseert een normale variabele

void *ptr;//Declareert de void pointer

ptr=#// Leidt Ptr-aanwijzer naar num

printf(“De waarde van de integer-variabele is %d”, *(int*)ptr );// Dereferentie door middel van typecasting

}

De waarde van de integer-variabele is 10.

Daarom kunnen we door type-casting ongeldige verwijzingen verwijderen.

Dus, terwijl aanwijzerberekeningen ongeldig zijn met lege aanwijzers, helpt typecasting dat probleem op te lossen. De uitvoer wordt:

(Void pointer maakt codering gemakkelijker door de locatie van gegevensvariabelen te onthullen)

• Met calloc() en malloc () helpt de void-aanwijzer bij het toewijzen van geheugenlocaties voor alle gegevenstypen.

Zie de onderstaande code ter illustratie:

int main(void)

{

// Merk op dat de functie malloc() void * . teruggeeft

// Opvolgen, type-cast naar elk datatype zoals char *, int *,...

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

}

Merk op dat het bovenstaande programma alleen in C compileert.

• Last but not least, de void pointer variabele helpt bij het implementeren van generieke functies in C.

Conclusie

De void pointer-functie is over het algemeen een essentieel programmeerhulpmiddel. Programmeurs vinden het handig omdat er geen gegevenstypen aan zijn gekoppeld. Het elimineert in ieder geval de verwarring van pointers die verschillende waarden en dataklassen naar elkaar verwijzen. Vandaar dat lege wijzers overtollig type-casting verminderen. Het ondersteunt ook generieke gegevens van het aanwijzertype. Daarom is het ook een compiler voor algemeen gebruik.

Je hebt een complete gids over het werken met void pointers in c. Als u echter vragen heeft of andere programmeerbronnen nodig heeft, is onze contactpagina altijd beschikbaar.