Können wir Strukturen nach der Hauptfunktion in C++ definieren?

Question

Können wir Struktur nach dem Hauptprogramm in C++ definieren? Wenn wir Funktionen definieren, können wir die Funktion vor dem Hauptprogramm deklarieren und dann die Funktionsdefinition nach der Hauptfunktion schreiben. Ich wollte wissen, ob wir bei der Definition von Strukturen etwas Ähnliches tun können. Vielen Dank.

Answer 1

Können wir Struktur nach dem Hauptprogramm in C++ definieren?

Ich nehme an, dass Sie die main Funktion meinen. Ja, wir können Klassen (einschließlich Strukturen) nach main Funktion definieren. Eine Demo:

int main(){} 
struct S{}; 

Wenn wir Funktionen definieren, können wir die Funktion vor dem Hauptprogramm deklariert und dann die Funktionsdefinition nach dem Hauptprogramm schreiben. Ich wollte wissen, ob wir bei der Definition von Strukturen etwas Ähnliches tun können.

Gleiches gilt für Klassen, die Sie vor einer Funktion (forward) deklarieren und danach definieren können. Die Verwendung von unvollständigen (deklarierten, aber nicht definierten) Klassen ist jedoch sehr begrenzt. Sie können Zeiger und Verweise auf sie definieren, aber Sie können sie nicht erstellen oder keine Mitgliedsfunktionen aufrufen. Eine Demo:

struct S;  // (forward) declaration of a class 
S* factory(); // (forward) declaration of a function 
int main(){ 
    S* s = factory(); // OK, no definition required 
    // s->foo();  // not OK, S is incomplete 
    // S s2;   // not OK 
} 
struct S{    // definition of a class 
    void foo();  // declaration of a member function 
}; 
S* factory() { 
    static S s;  // OK, S is complete 
    s.foo();   // OK, note how the member function can be called 
         // before it is defined, just like free functions 
    return &s; 
} 
void S::foo() {}  // definition of a member function 

Answer 2

Bearbeiten: Wie @ user2079303 in den Kommentaren erwähnt, habe ich den Begriff "Forward-Deklaration" falsch verwendet. Ich habe meine Antwort entsprechend aktualisiert.

Sie können Strukturen weiterleiten, wenn Sie nur einen Zeiger auf diese Struktur speichern möchten. Sie können Methoden für diesen Zeiger jedoch nur aufrufen, nachdem die Struktur definiert wurde.

Sie können auch Methoden von Strukturen in der Strukturdefinition weiterleiten, während Sie diese Methoden später definieren.

#include <iostream> 

// incomplete definition of struct S 
// methods of the struct are only declared here 
struct S 
{ 
    S(); 
    void foo(); 
    int bar; 
}; 

int main() 
{ 
    S s; 
    s.foo(); 
} 

// definition of the struct's methods 
S::S() : bar(42) {} 
void S::foo() { std::cout << "bar is " << bar << "\n"; } 

Diese Definition mit zukunfts deklarierten Methoden ist die hauptsächliche Verwendung von Header (.h-Dateien). Sie können Ihre Struktur in der Kopfzeile definieren und die Kopfzeile in die Dateien einfügen, in denen die Struktur verwendet wird. Die Definition Ihrer Methoden geht in die Quelldatei(). Angewandt auf den Code oben bedeutet das:

Datei S.h

struct S 
{ 
    S(); 
    void foo(); 
    int bar; 
}; 

Datei S.cpp

#include "S.h" 
#include <iostream> 

S::S() : bar(42) {} 
void S::foo() { std::cout << "bar is " << bar << "\n"; } 

Datei main.cpp

#include "S.h" 

int main() 
{ 
    S s; 
    s.foo(); 
} 

Wenn Sie kompilieren S.cpp und main.cpp und dann li Wenn Sie die resultierenden Objektdateien bearbeiten, erhalten Sie das gleiche Verhalten wie am Anfang des Codes.