Zusammenfassung der externen Nutzung

Das Problem bei Extern besteht darin, dass wir nicht wissen, ob dieses Schlüsselwort eine Deklaration oder eine Definition ist, wenn es erscheint.

Denken Sie daran: Deklarationen können mehrmals vorgenommen werden, Definitionen jedoch nur einmal.

Das Schlüsselwort extern ist in der Funktionsdeklaration optional, da die Funktion selbst ohne Änderung extern ist. Es muss jedoch beim Zitieren noch deklariert werden.

Wenn globale Variablen extern deklariert werden, ist das Schlüsselwort extern erforderlich. Wenn die Variable nicht extern geändert und nicht explizit initialisiert wird, wird sie auch zur Definition der Variablen, sodass zu diesem Zeitpunkt extern hinzugefügt werden muss Der hier markierte Speicherplatz des Compilers wird zur Ausführungszeit in den Speicher geladen und auf 0 initialisiert. Die Deklaration lokaler Variablen kann nicht mit extern geändert werden, und lokale Variablen weisen zur Laufzeit nur Speicher im Stapelteil zu.

Referenzaussage, Definitionsaussage

Starkes Symbol, schwaches Symbol

erscheint in der Linux-GCC-Linkanalyse, die das Linkverständnis vertiefen kann .

Es gibt im Wesentlichen keinen Unterschied zwischen einer globalen Variablen und einer Funktion. Der Funktionsname ist ein Zeiger auf den Anfang des Binärblocks der Funktion. Globale Variablen sind außerhalb der Funktion deklarierte Variablen. Der Funktionsname liegt auch außerhalb der Funktion, daher ist die Funktion auch global.

Bilden Sie bei der Verwendung einen Stil.

Header-Datei

Lassen Sie uns zunächst über die Header-Datei sprechen. Tatsächlich hat die Header-Datei keine Auswirkung auf den Computer. Sie erweitert sie lediglich an der Stelle #include. Kompilierung hat keine andere Bedeutung. Tatsächlich sind Header-Dateien hauptsächlich für andere sichtbar.

Ich habe ein Experiment durchgeführt, das Suffix der Header-Datei in xxx.txt geändert und dann

#include "xxx.txt" verwendet.

Die Kompilierung und Verknüpfung verlief reibungslos Es ist ersichtlich, dass die Header-Datei nur zum Lesen des Codes dient und keine andere Funktion hat!

Ob C oder C++, Sie fügen Ihre Funktionen, Variablen oder Strukturen, Klassen usw. in Ihre .c- oder .cpp-Datei ein. Kompilieren Sie es dann in lib, dll, obj, .o usw. und verwenden Sie dann das einfachste gcc hisfile.cpp yourfile.o|obj|dll|lib usw., wenn andere es verwenden.
Aber woher wissen wir Programmierer, was in Ihrer Bibliothek, DLL ... enthalten ist? Es hängt von Ihrer Header-Datei ab. Ihre Header-Datei ist eine Beschreibung für den Benutzer. Beschreibungen von Funktionen, Parametern und verschiedenen Schnittstellen.
Da es sich um eine Erklärung handelt, wird in der Header-Datei natürlich die „Deklaration“ über Funktionen, Variablen und Klassen abgelegt. Denken Sie daran, es handelt sich um eine „Aussage“ und nicht um eine „Definition“.
Ich gehe also davon aus, dass Sie alle den Unterschied zwischen Deklaration und Definition kennen. Daher ist es am besten, in der Header-Datei nichts Dummes zu definieren. Zum Beispiel globale Variablen:

#ifndef _XX_header.H
#define _XX_header.H
int A;
#endif

Nun, das ist schlecht. Die Sache ist, Das int A hier ist die Definition einer globalen Variablen. Wenn also mehrmals auf diese Header-Datei verwiesen wird, wird Ihr A wiederholt definiert
Offensichtlich ist die Syntax falsch. Mit dieser bedingten #ifndef-Kompilierung kann jedoch sichergestellt werden, dass nur einmal auf Ihre Header-Datei verwiesen wird. Es kann jedoch trotzdem zu Fehlern kommen ist auf diese C-Quelldatei beschränkt, sodass beim Kompilieren dieser mehreren C-Dateien keine Fehler auftreten. Beim Verknüpfen wird jedoch ein Fehler gemeldet, der besagt, dass Sie dieselbe Variable an mehreren Stellen definiert haben.

Verknüpfung. ..
incl2.obj: Fehler LNK2005: „int glb“ (?glb@@3HA) bereits in incl1.obj definiert
Debug/incl.exe: Schwerwiegender Fehler LNK1169: Ein oder mehrere mehrfach definierte Symbole gefunden

Achtung! ! !

extern

Dieses Schlüsselwort ist wirklich hasserfüllt. Bei der Deklaration kann dieses Extern tatsächlich weggelassen werden, sodass Sie verwirrt sind, ob es sich um eine Deklaration oder eine Definition handelt und Es gibt zwei Arten von Funktionen:

(1) Variablen

speziell für Variablen.
extern int a;//Deklarieren Sie eine globale Variable a
int a; //Definieren Sie eine globale Variable a

extern int a =0;//Definieren Sie eine globale Variable a und geben Sie einen Anfangsbuchstaben an Wert .
int a =0;//Definieren Sie eine globale Variable a und geben Sie ihr einen Anfangswert.

Sie definieren beide eine globale Variable, die extern verwendet werden kann Geben Sie ihm einen Anfangswert.
Du bist verwirrt, sie sehen sich wirklich ähnlich. Die Definition kann jedoch nur an einer Stelle erscheinen. Mit anderen Worten, ob es sich um int a; oder extern int a=0; oder int a=0; handelt, es kann nur einmal vorkommen, aber dieses externe int a kann mehrmals vorkommen.

Wenn Sie auf eine globale Variable verweisen möchten, müssen Sie extern int a deklarieren; extern kann zu diesem Zeitpunkt nicht weggelassen werden, denn wenn es weggelassen wird, wird es zu int a; .

(2) Funktion
Funktion, Funktion, das Gleiche gilt für Funktionen, sie werden auch definiert und deklariert. Verwenden Sie beim Definieren extern, um anzugeben, dass auf diese Funktion extern verwiesen werden kann dass das eine Aussage ist. Da es jedoch einen Unterschied zwischen der Definition und der Deklaration einer Funktion gibt, muss eine definierte Funktion einen Funktionskörper haben, während eine deklarierte Funktion keinen Funktionskörper hat, sodass extern bei der Definition und Deklaration einer Funktion weggelassen werden kann. Andere Dateien wissen auch, dass diese Funktion an anderer Stelle definiert ist, daher ist es in Ordnung, extern nicht hinzuzufügen. Die beiden sind so unterschiedlich, dass es kein Problem darstellt, wenn extern weggelassen wird.
Zum Beispiel:

int fun(void)
{
return 0;
}

Großartig, wir haben eine globale Funktion definiert

int fun(void);
Wir machen eine Deklaration dafür und können sie dann später verwenden
Es spielt keine Rolle, ob wir extern hinzufügen oder nicht
Wir können die Fun-Deklaration auch in a einfügen Header-Datei und wird schließlich so:

int fun(void);//Funktionsdeklaration, daher wird extern weggelassen und die vollständige Version ist extern int fun(void);

int fun (void)
{
return 0;
}//Eine vollständige globale Funktionsdefinition, da es einen Funktionskörper gibt, wird auch extern weggelassen.
Dann fügt ein Kunde, ein Kunde, der Ihren Spaß nutzen möchte, diese Header-Datei ein, ok, eine globale Anweisung. Kein Problem.
Wenn dieser Kunde jedoch globale Variablen verwenden möchte, muss eine bestimmte Variable extern sein, andernfalls wird sie zu einer Definition.

Um es zusammenzufassen:

Wenn Sie bei Variablen eine Variable aus einer anderen Quelldatei in dieser Quelldatei verwenden möchten, müssen Sie die Variable vor der Verwendung mit extern oder in der Header-Datei deklarieren Verwenden Sie extern, um die Variable zu deklarieren.

Wenn Sie eine Funktion aus einer anderen Quelldatei in dieser Quelldatei verwenden möchten, müssen Sie die Variable vor der Verwendung deklarieren Funktion mit oder ohne extern. Es spielt keine Rolle, Sie müssen also nicht extern zur Funktion in der Header-Datei hinzufügen.

Deklaration wird verwendet, um die Bedeutung jedes Bezeichners zu erklären, ohne vorher Speicherplatz für jeden Bezeichner zu speichern. Die Deklaration des reservierten Speicherplatzes wird als Definition bezeichnet. Die Form der Deklaration ist: Deklarationsspezifizierer Deklarator Deklarator besteht aus Speicherklassenspezifizierer und Typspezifizierer.

1. Bei der Deklaration von Variablen gibt es zwei Situationen: Die eine erfordert die Schaffung von Speicherplatz.
Zum Beispiel: int a hat bei der Deklaration bereits einen Speicherplatz erstellt.
2. Das andere ist, dass kein Speicherplatz geschaffen werden muss.
Zum Beispiel: extern int a, wobei die Variable a in einer anderen Datei definiert ist.

Beispiel 1:
Deklaration.
Ein Konstrukt, das einem Variablennamen oder einer Funktion Attribute zuordnet. Zum Beispiel:
extrn int a;
extrn char c ;
Variablendeklaration Eine Strukturdeklaration könnte wie folgt aussehen:

Definition.
Variablendefinition ist eine Deklaration mit Speicherzuweisung.

struct per_rec
{
int age;
char *Nachname;
char *Vorname;

};

int a;
char c;
struct per_rec person;

Ein Konstrukt, das den Namen, die Parameter und den Rückgabetyp einer Funktion angibt. Eine Funktionsdefinition wäre beispielsweise:

long sqr(int num)
{
return(num*num);
}

Ersteres ist eine „definierende Deklaration“ „ oder „Definition“, die eine „verweisende Deklaration“ ist. Im Großen und Ganzen enthalten Deklarationen Definitionen, aber nicht alle Deklarationen sind Definitionen. Beispiel: int a ist sowohl eine Deklaration als auch eine Definition. Bei extern a handelt es sich jedoch nur um eine Deklaration und nicht um eine Definition. Es kann wiederholt im selben Quellprogramm oder in verschiedenen Quellprogrammen deklariert werden. Unter normalen Umständen beschreiben wir es oft so, dass wir die Anweisung, die einen Speicherplatz erstellt, als „Definition“ bezeichnen und eine Anweisung, die die Erstellung eines Speicherplatzes nicht erfordert, als „Deklaration“ bezeichnen. Offensichtlich ist die Aussage, auf die wir uns hier beziehen, relativ eng gefasst, das heißt, es handelt sich um eine Nicht-Definitions-Aussage.
Zum Beispiel: in der Hauptfunktion

int main()
{
int a; //Hier ist die Definition (Deklaration des zugewiesenen Speicherplatzes ), Es kann nicht wiederholt vorkommen
//Wenn Sie hier extern int a; schreiben, wird beim Kompilieren in VC6.0 ein Fehler gemeldet

//(Neudefinition)

//Int a hier schreiben; in DEV-C++ kompilieren und einen Fehler melden.
//Extern int a hier kompilieren -C++, läuft problemlos
extern int A; //Dies ist eine Deklaration und keine Definition.
//Hinweis: Sie können den Variablentyp entfernen, wenn Sie eine externe Variable deklarieren Variable, wie zum Beispiel: extern A;
dosth(); //Funktion ausführen
}
int A; //Es ist die Definition, die A als externe Variable vom Typ Integer definiert

Siehe Ob definiert oder deklariert werden soll, hat manchmal etwas mit der Verarbeitung des Compilers zu tun.

Die „Definition“ einer externen Variablen unterscheidet sich von der „Deklaration“ einer externen Variablen. Eine externe Variable kann nur einmal definiert werden und ihr Speicherort liegt außerhalb aller Funktionen, während sich externe Variablen in derselben Datei befinden Die Variablendeklaration kann mehrfach erfolgen, sie kann innerhalb einer Funktion (jede Funktion, die verwendet werden soll, muss in dieser Funktion deklariert werden) oder außerhalb der Funktion (vor dem Definitionspunkt der externen Variablen) erfolgen. Das System weist Speicherplatz basierend auf der Definition externer Variablen zu (und nicht auf der Deklaration externer Variablen). Bei externen Variablen kann die Initialisierung nur in der „Definition“ erfolgen, nicht in der „Deklaration“.
Die Funktion der sogenannten „Deklaration“ besteht darin, zu deklarieren, dass es sich bei der Variablen um eine später definierte externe Variable handelt. Es handelt sich lediglich um eine „Deklaration“, um die Variable „im Voraus“ zu referenzieren. extern macht lediglich eine Aussage und trifft keine Definitionen.

Die Verwendung von static zum Deklarieren einer Variablen hat zwei Auswirkungen:
(1) Wenn Sie eine lokale Variable als static deklarieren, bleibt der für die Variable zugewiesene Speicherplatz während der gesamten Ausführungsperiode des Programms immer vorhanden.
(2) Wenn die externe Variable als statisch deklariert ist, ist die Rolle der Variablen auf dieses Dateimodul beschränkt.

#include "stdafx.h"
1.extern wird häufig in Variablendeklarationen verwendet. Sie deklarieren eine globale Variable in der *.c-Datei. Wenn darauf verwiesen werden soll, Fügen Sie es in *.h ein und deklarieren Sie es mit extern.
2. Wenn das Schlüsselwort extern in der Funktionsdeklaration enthalten ist, bedeutet dies nur, dass die Funktion in anderen Quelldateien definiert werden kann und keine weiteren Auswirkungen hat. Das heißt, es gibt keinen Unterschied zwischen den folgenden beiden Funktionsdeklarationen:
extern int f(); und int f();
＝＝＝＝＝＝＝＝＝＝＝＝＝＝ ＝＝＝ ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Wenn die c/cpp-Datei, die die Funktion definiert, die definierte Funktion in der entsprechenden Header-Datei deklariert, muss sie in verwendet werden andere c/cpp-Dateien Diese Funktionen müssen nur diese Header-Datei enthalten.
Wenn Sie die Header-Datei nicht einschließen möchten, deklarieren Sie die Funktion in c/cpp. Im Allgemeinen wird „extern“ nicht zum Deklarieren von in dieser Datei definierten Funktionen verwendet, und „extern“ wird zum Deklarieren von in anderen Dateien definierten Funktionen verwendet. Auf diese Weise besteht keine Notwendigkeit, Funktionen aufzurufen, die in anderen Dateien in dieser Datei definiert sind um die Header-Datei einzuschließen
 include „*.h“, um die Funktion zu deklarieren und sie direkt nach der Deklaration zu verwenden.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ ＝＝＝＝＝＝＝＝＝ ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ ＝＝＝＝＝＝＝＝＝＝ ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ ＝＝＝＝＝＝＝＝＝　
Zum Beispiel:
//extern.cpp-Inhalt lautet wie folgt:

// extern.cpp: Definiert den Einstiegspunkt für die Konsolenanwendung.
//

#include "stdafx.h"
extern print(char *p);
int main(int argc, char* argv[] )
{
 char *p="hello world!";
 print(p);
 return 0;
}
 //Der Inhalt von print.cpp lautet wie folgt
 #include „stdafx.h“
#include „stdio.h“
print(char *s)
{
 printf("Die Zeichenfolge ist %sn ",s);
}
Das Ergebnisprogramm kann normal ausgeführt werden und die Ergebnisse ausgeben. Wenn Sie „extern“ entfernen, kann das Programm weiterhin normal ausgeführt werden.

Es ist ersichtlich, dass „extern“ in der Funktionsdeklaration entbehrlich ist. Es wird nur verwendet, um anzugeben, ob die Funktion in dieser Datei oder in einer anderen Datei definiert ist. Solange Ihre Funktion vor der Verwendung deklariert wird, müssen Sie die Header-Datei nicht einbinden.

In der C-Sprache wird der Modifikator extern vor der Deklaration einer Variablen oder Funktion verwendet, um anzugeben, dass „diese Variable/Funktion an anderer Stelle definiert ist und hier referenziert werden sollte“.

0. Extern geänderte Variablendeklaration. Wenn beispielsweise die Datei a.c auf die Variable int v in b.c verweisen muss, können Sie extern int v in a.c deklarieren und dann auf die Variable v verweisen. Hierbei ist zu beachten, dass das Link-Attribut der referenzierten Variablen v ein externer Link (extern) sein muss, damit a.c auf v verweist. Dies hängt nicht nur von der Deklaration von extern int v in a.c ab. hängt aber auch von der Variablen v selbst ab, die in Anführungszeichen gesetzt werden kann. Dies betrifft ein weiteres Thema in der C-Sprache – den Umfang von Variablen. Variablen, auf die andere Module mit dem Modifikator extern verweisen können, sind normalerweise globale Variablen. Ein weiterer sehr wichtiger Punkt ist, dass extern int v an einer beliebigen Stelle in a.c platziert werden kann. Sie können beispielsweise extern int v am Anfang der Definition der Funktion fun in a.c deklarieren und dann auf die Variable v verweisen kann nur im Funktionsumfang auf v verweisen. Dies ist immer noch ein Problem des Variablenumfangs. Diesbezüglich haben viele Menschen Bedenken bei der Verwendung. Es scheint, dass die externe Anweisung nur im Dateibereich verwendet werden kann.

1. Extern geänderte Funktionsdeklaration. Im Wesentlichen gibt es keinen Unterschied zwischen Variablen und Funktionen. Der Funktionsname ist ein Zeiger auf den Anfang des Binärblocks der Funktion. Wenn die Datei a.c beispielsweise auf eine Funktion in b.c verweisen muss, ist der Prototyp in b.c int fun (int mu), dann können Sie extern int fun (int mu) in a.c deklarieren und dann fun verwenden, um alles zu tun. Genau wie die Deklaration einer Variablen kann extern int fun (int mu) an einer beliebigen Stelle in a.c platziert werden und muss nicht unbedingt im Dateibereich von a.c platziert werden. Die häufigste Art, auf Funktionen in anderen Modulen zu verweisen, sind Header-Dateien, die Deklarationen dieser Funktionen enthalten. Was ist der Unterschied zwischen der Verwendung von extern und dem Einfügen einer Header-Datei zum Verweisen auf eine Funktion? Die externe Referenzmethode ist viel einfacher als das Einbinden der Header-Datei! Die Verwendung von extern ist unkompliziert. Verwenden Sie extern, um zu deklarieren, auf welche Funktion Sie verweisen möchten. Dies ist wahrscheinlich eine Manifestation des KISS-Prinzips! Ein offensichtlicher Vorteil dieser Vorgehensweise besteht darin, dass der Prozess der Programmkompilierung (genauer gesagt die Vorverarbeitung) beschleunigt und Zeit gespart wird. Dieser Unterschied wird bei der Kompilierung großer C-Programme sehr deutlich.

2. Darüber hinaus kann der externe Modifikator verwendet werden, um die aufrufende Spezifikation von C- oder C++-Funktionen anzugeben. Um beispielsweise eine C-Bibliotheksfunktion in C++ aufzurufen, müssen Sie extern „C“ verwenden, um die Funktion zu deklarieren, auf die im C++-Programm verwiesen werden soll. Dies wird vom Linker verwendet, um ihn anzuweisen, beim Linken die C-Funktionsspezifikation zu verwenden. Der Hauptgrund ist, dass die Benennungsregeln im Zielcode nach der Kompilierung von C++- und C-Programmen unterschiedlich sind

Weitere Artikel zum Thema Zusammenfassung der externen Nutzung, bitte beachten Sie die chinesische PHP-Website!