Statische und externe Zeiger in C/C++

Statische und externe Zeiger in C/C++

Static und extern sind Speicherklassen in C, die den Umfang und die Lebensdauer einer Variablen definieren. Ähnlich wie alle Variablen in C können wir diese Schlüsselwörter mit Zeigern für verschiedene Anwendungsfälle verwenden.

Inhaltsverzeichnis:

  1. Statische Zeiger in C/C++
  2. Externe Zeiger in C/C++

Fangen wir an.

Statische Zeiger in C/ C++

Statisch Einmal initialisierte Variablen existieren bis zur Beendigung des Programms. Diese Variablen behalten ihren Wert auch dann, wenn sie außerhalb ihres Gültigkeitsbereichs liegen. Sobald sie deklariert und initialisiert sind, werden sie nicht erneut deklariert, d. h. wenn der Speicher einmal zugewiesen ist, dann existieren sie bis zur Beendigung dieses Programms. Eine statische Zeigerdeklaration wie unten gezeigt.

static int * ptr; // A static pointer of type int is defined    

Diese Deklaration besagt, dass der Zeiger selbst eine statische Speicherdauer haben sollte. und sagt nichts über die Speicherklasse des Dings aus, auf das der Zeiger zeigt. Das könnte sich zu verschiedenen Zeitpunkten während der Ausführung des Programms ändern, indem Sie einfach diesem Zeiger unterschiedliche Werte zuweisen.

Der Umfang dieser Variablen hängt davon ab, wo sie deklariert sind. Ihr Gültigkeitsbereich ist lokal, wenn die Variable innerhalb der Funktion deklariert wird. Wenn die statische Variable in der Globle-Region deklariert ist, kann überall im Programm oder in dieser bestimmten C-Datei darauf zugegriffen werden. Ein Anfangswert 0 oder NULL wird vom Compiler zugewiesen. Ein Beispiel dafür ist unten angegeben.

#include <stdio.h>

void foo(){
int a = 10, b = 20;     
static int *c; //static pointer variable declaration
//re-declaration is not done in case of static variables

if(c == 0)
    c = &a; 
else
    c = &b;

printf("value = %d\n", *c);
printf("address of pointer = %d\n", &c);
printf("address of memory pointed by pointer c = %d\n", c);
printf("address of a = %d\n", &a);
printf("address of b = %d\n", &b);    
}

int main(){
    foo();
    foo();
}    

Ausgabe:

value = 10
address of pointer = 4218932
address of memory pointed by pointer c = 6422204
address of a = 6422204
address of b = 6422200
value = 20
address of pointer = 4218932
address of memory pointed by pointer c = 6422200
address of a = 6422204
address of b = 6422200    

Im obigen Programm wird eine Funktion foo() von main() aufgerufen. In der ersten Iteration enthält die vom Compiler initialisierte statische Variable „0“ (Null), sodass der Wert „a“ zugewiesen wird, und da es sich um eine statische Variable handelt, hält sie diesen auch nach Abschluss der Funktionsausführung. Damit wird in der zweiten Iteration von foo() der statische Zeiger 'c' dem Wert von b zugewiesen. Dasselbe können wir im Ausgabefenster beobachten. Die Adresse des statischen Zeigers ist während der gesamten Ausführung des Programms konstant. Aber wohin es zeigt, kann geändert werden.

Mit einem statischen Zeiger kann eine Funktion implementiert werden, die immer denselben Puffer an das Programm zurückgibt. Dies kann bei der seriellen Kommunikation hilfreich sein.

char * Buffer(){
static char *buff;

if(buff == 0)
    buff = malloc( BUFFER-SIZE );

return buff;
}

Externe Zeiger in C/C++

Extern Die Speicherklasse gibt an, dass die Variable an anderer Stelle in einem großen Programm definiert ist. Durch die Angabe einer Variablen als Extern kann der Programmierer eine an anderer Stelle deklarierte Variable so verwenden, als ob sie lokal deklariert wäre. Eine externe Variable ist nichts anderes als eine globale Variable, die mit einem zulässigen Wert initialisiert wird, wo sie deklariert wird, um an anderer Stelle verwendet zu werden. Diese Variablen können nur global und nur einmal initialisiert, aber je nach Anforderung beliebig oft deklariert werden. Den als extern deklarierten Variablen wird kein Speicher zugewiesen.

#include <stdio.h>

void foo(){  
int a = 11;
extern int *ptr; 
//specifies compiler to search for this variable outside this function

printf("Default value = %d (NULL pointrer)\n", ptr);
ptr = &a;
printf("After assignment %d\n", *ptr);
}

int main(){
    foo();
}

int *ptr; // Globle pointer declaration
// pointer initialized by compiler - null pointer

Ausgabe:

Default value = 0 (NULL pointrer)  
After assignment 11

Durch die Verwendung von Exrern-Zeigern können global verfügbare Zeiger erstellt werden, die in verschiedenen Szenarien nützlich sein können. Eine seiner Verwendungen ist der Zugriff auf Befehlszeilenargumente von der Hauptfunktion in anderen Dateien oder der Funktion eines Projekts.

extern int ArgC = 0;
extern char ** ArgV = 0;

int main( int argc, char ** argv ) {
   ArgC = argc;
   ArgV = argv;
   ...
}

Mit diesem Artikel bei OpenGenus müssen Sie die vollständige Vorstellung von statischen und externen Zeigern in C/C++ haben.