Moeiteloze Pointer Array Initialisatie In C: Tips & Best Practices
Een pointer is een variabele die het adres van een andere variabele opslaat. De naam van de pointer variabele moet voorafgegaan worden door het "*" symbool. Net als bij een normale variabele kunnen we ook een "array van pointers" declareren, waarbij elk subscript van het array het adres van een array type bevat.
Hoe Initialiseer Je Een Array Van Pointers In C?
Een pointer variabele kan geïnitialiseerd worden op het moment van declaratie, door het het adres van een bestaande variabele toe te wijzen. Het volgende snippet laat zien hoe je een pointer kunt initialiseren:
int x = 10; int *y = &x;
Standaard behoren alle variabelen, inclusief pointer variabelen, tot de "auto storage class". Dit betekent dat een pointer variabele een onvoorspelbaar, garbage, willekeurig geheugenadres opslaat, wat kan leiden tot undefined behavior en potentiële risico's voor een programma, zoals segmentation fault errors. Daarom moet het geïnitialiseerd worden naar NULL als we op het moment van declaratie geen specifieke waarde hebben om op te slaan.
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.
Array Van Pointers Initialiseren Met static Keyword
Je kunt ook het static keyword gebruiken om een array van pointers 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;
}
Output
Draai de code en check de output:
ptr[0]= 0 ptr[1]= 0 ptr[2]= 0 ptr[3]= 0 ptr[4]= 0
Array Van Integer Pointers Initialiseren
Hier declareren we een array van integer pointers en slaan we de adressen van drie integer variabelen op.
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]: adres: %d waarde: %d\n", i, ptr[i], *ptr[i]);
}
return 0;
}
Output
Draai de code en check de output:
ptr[0]: adres: 6422040 waarde: 10 ptr[1]: adres: 6422036 waarde: 20 ptr[2]: adres: 6422032 waarde: 30
Array Van Pointer Initialiseren Met Directe Adressen
We kunnen het adres van elk element van een normale array opslaan in het corresponderende element van een pointer array.
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]: adres: %d waarde: %d\n", i, ptr[i], *ptr[i]);
}
return 0;
}
Output
Draai de code en check de output:
ptr[0]: adres: 6422032 waarde: 10 ptr[1]: adres: 6422036 waarde: 20 ptr[2]: adres: 6422040 waarde: 30
Een Array Doorlopen 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 incrementeert met de grootte van het datatype.
Dus met alleen het basisadres (de naam van de array is hetzelfde als het adres van het 0-de element), kunnen we een array doorlopen.
Voorbeeld 1
Bekijk 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]: adres: %d waarde: %d\n", i, ptr+i, *(ptr+i));
}
return 0;
}
Output
Draai de code en check de output:
ptr[0]: adres: 6422020 waarde: 10 ptr[1]: adres: 6422024 waarde: 20 ptr[2]: adres: 6422028 waarde: 30
Voorbeeld 2: Een 2D Array Doorlopen Met Een Pointer Array
In dit voorbeeld hebben we een 2D array. Het adres van het 0-de element van elke rij wordt opgeslagen in een pointer array. Bij het doorlopen wordt het adres opgeslagen in elk element van de pointer array, dat wijst naar het 0-de element van de corresponderende rij, elk geïncrementeerd 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 het element van de 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;
}
Output
Wanneer je deze code runt, produceert het de volgende output:
1 2 3 4 5 6 7 8
Voorbeeld 3
We hebben eigenlijk geen pointer array nodig, want we kunnen de naam van deze 2D array als zijn basispointer gebruiken, en het rij- en kolomgewijs incrementeren 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 het element van de 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;
}
Output
De output lijkt op die van de vorige code:
1 2 3 4 5 6 7 8
Array Van Character Pointers (String) Initialiseren
In C programmeren is een string een array van char datatype. Aangezien de naam van een array ook het adres van zijn 0-de element vertegenwoordigt, kan een string gedeclareerd worden als:
char arr[] = "Hello";
Met de pointer notatie wordt een string toegewezen aan een char pointer als:
char *arr = "Hello";
We kunnen dan een array van char pointers declareren om meerdere strings op te slaan als volgt:
char *arr[3] = {"string1", "string2", "string3", ... };
Voorbeeld
Het volgende voorbeeld heeft een array van char pointers die gebruikt wordt om de namen van programmeertalen 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;
}
Output
Wanneer je deze code runt, produceert het de volgende output:
PYTHON JAVASCRIPT PHP NODE JS HTML KOTLIN C++ REACT JS RUST VBSCRIPT
In dit programma is "langs" een pointer naar een array van 10 strings. Dus als "langs[0]" wijst naar adres 5000, dan zal "langs + 1" wijzen naar adres 5004 wat de pointer naar de tweede string opslaat.
Daarom kunnen we ook de volgende variatie van de lus gebruiken om de array van strings te printen:
for (int i = 0; i < 10; i++){
printf("%s\n", *(langs + i));
}
Initialisatie Van Dynamische Array Van Pointers
Je kunt de malloc() functie gebruiken om een array van pointers op een dynamische manier te declareren en te initialiseren.
Voorbeeld
Bekijk het volgende voorbeeld:
#include <stdio.h>
#include <stdlib.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;
}
Output
Wanneer je deze code runt, produceert het de volgende output:
0 0 1 1 2 2 3 3 4 4
Je kunt zelfs om user input 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;
}
C Taal
- Method overloading in C#: concepten, voorbeelden en best practices
- C# Erfelijkheid Beheersen: Herbruikbare, Onderhoudbare Code Bouwen
- C# Partial Classes en Methods: Een Praktische Gids
- Karakterwijzers en Functiegebruik in C onder de knie krijgen
- C Input en Output (I/O) Beheersen: scanf() en printf() Uitgelegd
- C Datatypes Uitgelegd: int, float, char en Meer – Een Complete Gids
- C++ comments: best practices voor leesbare, onderhoudbare code
- C-opslagklassen: Scope, levensduur en gebruik
- C++ Signaalverwerking onder de knie: Veilige interruptafhandeling en schone programmaterminatie
- C++ for loops: stap-voor-stap gids
- C++ arrays: declaratie, initialisatie en praktische voorbeelden