Moeiteloze pointerarray-initialisatie in C:tips en best practices

Een pointer is een variabele die het adres van een andere variabele opslaat. De naam van de pointervariabele moet worden voorafgegaan door het symbool "*". Net als bij een normale variabele kunnen we ook een "array van pointers" declareren, waarbij elk subscript van de array het adres van een arraytype bevat.

Hoe initialiseer ik een reeks pointers in C?

Een pointervariabele kan worden geïnitialiseerd op het moment van declaratie, door deze het adres van een bestaande variabele toe te wijzen. Het volgende fragment laat zien hoe u een aanwijzer kunt initialiseren −

int x = 10;
int *y = &x;

Standaard behoren alle variabelen, inclusief de pointervariabelen, tot de "automatische opslagklasse". Het betekent dat een pointervariabele een onvoorspelbaar, rommelig, willekeurig geheugenadres opslaat, wat kan leiden tot ongedefinieerd gedrag en potentiële risico's voor een programma, zoals segmentatiefoutfouten. Daarom moet het worden geïnitialiseerd op NULL als we geen specifieke waarde hebben om op te slaan op het moment van declaratie.

int *ptr = NULL;

Een "pointer array" slaat het adres in elk element op. Het type van de array moet overeenkomen met het type van de doelvariabele.

Initialiseer een reeks verwijzingen met behulp van een statisch trefwoord

U kunt ook het statische sleutelwoord gebruiken om een reeks verwijzingen te initialiseren om "0" in elk subscript op te slaan.

Voorbeeld

#include <stdio.h>
int main(){
 static int *ptr[5];
 for (int i = 0; i < 5; i++){
 printf("ptr[%d] = %d\n", i, ptr[i]); 
 }
 
 return 0;
}

Uitvoer

Voer de code uit en controleer de uitvoer −

ptr[0]= 0
ptr[1]= 0
ptr[2]= 0
ptr[3]= 0
ptr[4]= 0

Initialiseer een reeks gehele aanwijzers

Hier declareren we een array van integer-pointers en slaan we de adressen op van drie integer-variabelen.

Voorbeeld

#include <stdio.h>
int main(){
 int a = 10, b = 20, c = 30;
 int *ptr[3] = {&a, &b, &c};
 for (int i = 0; i < 3; i++){
 printf("ptr[%d]: address: %d value: %d\n", i, ptr[i], *ptr[i]);
 }
 
 return 0;
} 

Uitvoer

Voer de code uit en controleer de uitvoer −

ptr[0]: address: 6422040 value: 10
ptr[1]: address: 6422036 value: 20
ptr[2]: address: 6422032 value: 30

Initialiseer de reeks aanwijzers op basis van directe adressen

We kunnen het adres van elk element van een normale array opslaan in het overeenkomstige element van een pointerarray.

Voorbeeld

#include <stdio.h>
int main(){
 int arr[] = {10, 20, 30};
 int *ptr[3] = {&arr[0], &arr[1], &arr[2]};
 for (int i = 0; i < 3; i++){
 printf("ptr[%d]: address: %d value: %d\n", i, ptr[i], *ptr[i]);
 }
 
 return 0;
}

Uitvoer

Voer de code uit en controleer de uitvoer −

ptr[0]: address: 6422032 value: 10
ptr[1]: address: 6422036 value: 20
ptr[2]: address: 6422040 value: 30

Een array doorkruisen met zijn basisadres

Wanneer we het basisadres van een array verkrijgen (in dit geval "&arr[0]"), kunnen we de adressen van de daaropvolgende elementen verkrijgen, wetende dat de pointer toeneemt met de grootte van het gegevenstype.

Daarom kunnen we, alleen met het basisadres (de naam van de array is dezelfde als het adres van het 0e element), een array doorlopen.

Voorbeeld 1

Kijk eens naar het volgende voorbeeld −

#include <stdio.h>
int main(){
 int arr[] = {10, 20, 30};
 int *ptr=arr;
 for (int i = 0; i < 3; i++){
 printf("ptr[%d]: address: %d value: %d\n", i,ptr+i, *(ptr+i));
 }
 
 return 0;
}

Uitvoer

Voer de code uit en controleer de uitvoer −

ptr[0]: address: 6422020 value: 10
ptr[1]: address: 6422024 value: 20
ptr[2]: address: 6422028 value: 30

Voorbeeld 2:een 2D-array doorkruisen met behulp van een pointer-array

In dit voorbeeld hebben we een 2D-array. Het adres van het nulde element van elke rij wordt opgeslagen in een pointerarray. Bij het doorlopen wordt het adres opgeslagen in elk element van de pointer-array, dat verwijst naar het nulde element van de overeenkomstige rij, elk verhoogd om de waarden in elke rij op te halen.

#include <stdio.h>
int main(){
 // 2d array
 int arr[3][4] = {
 {1, 2, 3, 4},
 {5, 6, 7, 8},
 };
 int ROWS = 2, COLS = 4;
 int i, j;
 // pointer
 int (*ptr)[4] = arr;
 // print the element of the array via pointer ptr
 for (i = 0; i < ROWS; i++) {
 for (j = 0; j < COLS; j++) {
 printf("%d ", *(ptr[i]+j));
 }
 printf("\n");
 }
 
 return 0;
}

Uitvoer

Wanneer u deze code uitvoert, zal deze de volgende uitvoer produceren −

1 2 3 4 
5 6 7 8

Voorbeeld 3

We hebben hier niet echt een pointerarray nodig, omdat we de naam van deze 2D-array als basispointer kunnen gebruiken en deze rij- en kolomsgewijs kunnen verhogen om de elementen in de gegeven 2D-array op te halen −

#include <stdio.h>
int main(){
 // 2d array
 int arr[3][4] = {
 {1, 2, 3, 4},
 {5, 6, 7, 8},
 };
 int ROWS = 2, COLS = 4;
 int i, j;
 // pointer
 int *ptr = arr;
 // print the element of the array via pointer ptr
 for (i = 0; i < ROWS; i++){
 for (j = 0; j < COLS; j++){
 printf("%d ", *(ptr + i * COLS + j));
 }
 printf("\n");
 }
 
 return 0;
}

Uitvoer

De uitvoer lijkt op die van de vorige code −

1 2 3 4 
5 6 7 8

Initialiseer een reeks tekenaanwijzers (tekenreeks)

Bij C-programmeren is een string een array van char-gegevenstype. Omdat de naam van een array ook het adres van het 0e element vertegenwoordigt, kan een string worden gedeclareerd als −

char arr[] = "Hello";

Met behulp van de pointernotatie wordt een string toegewezen aan een char-pointer als −

char *arr = "Hello";

We kunnen dan als volgt een array van char-pointers declareren om meerdere strings op te slaan −

char *arr[3] = {"string1", "string2", "string3", . . . };

Voorbeeld

Het volgende voorbeeld heeft een array van char-pointers die worden gebruikt om de namen van computertalen op te slaan −

#include <stdio.h>
int main(){
 char *langs [10] = {
 "PYTHON", "JAVASCRIPT", "PHP",
 "NODE JS", "HTML", "KOTLIN", "C++",
 "REACT JS", "RUST", "VBSCRIPT"
 };
 for(int i = 0; i < 10; i++)
 printf("%s\n", langs[i]);
 return 0;
}

Uitvoer

Wanneer u deze code uitvoert, zal deze de volgende uitvoer produceren −

PYTHON
JAVASCRIPT
PHP
NODE JS
HTML
KOTLIN
C++
REACT JS
RUST
VBSCRIPT

In dit programma is "langs" een verwijzing naar een array van 10 strings. Als "langs[0]" naar adres 5000 verwijst, verwijst "langs + 1" naar adres 5004, waar de verwijzing naar de tweede string is opgeslagen.

Daarom kunnen we ook de volgende variant van de lus gebruiken om de reeks strings af te drukken −

for (int i = 0; i < 10; i++){
 printf("%s\n", *(langs + i));
}

Initialisatie van dynamische reeks aanwijzers

U kunt de functie malloc() gebruiken om een array van pointers op een dynamische manier te declareren en te initialiseren.

Voorbeeld

Kijk eens naar het volgende voorbeeld −

#include <stdio.h>
int main(){
 int *arr = (int *)malloc (sizeof (int) * 5); 
 for(int i = 0; i < 5; i++){
 arr[i] = i;
 }
 for (int x = 0; x < 5; x++){
 printf("%d %d\n", x, arr[x]);
 }
 
 return 0;
}

Uitvoer

Wanneer u deze code uitvoert, zal deze de volgende uitvoer produceren −

0 0
1 1
2 2
3 3
4 4

Je kunt zelfs om gebruikersinvoer vragen en de waarden toewijzen aan de elementen in de pointer van arrays −

for(i = 0; i < 5; i++){
 scanf("%d", &x);
 arr[i] = x;
}