Übergabe von Strukturparameter an eine Funktion innerhalb einer Struktur

Question

Ich bin derzeit mit einem Problem mit Strukturen in C++ konfrontiert. Folgen Sie dem unten stehenden Code und dann kann ich das Problem erklären.

void TestFunction(testStructure *tempStructValue) 
{ 

    cout << tempStructValue->data << endl; 

    return &tempStructValue->data; 

} 

typedef struct testStructure 

{ 

    int data; 

    void *TestFunction(testStructure *tempStructValue) 

}temp; 

Die Funktion ist vor der Struktur definiert. Auf diese Weise hat die Funktion einen Parameter als Struktur, aber die Struktur wird nach der Definition der Funktion definiert. Dies ist offensichtlich ein Fehler.

Jetzt denken Sie anders herum. Definieren Sie die Struktur vor der Funktion. Dies würde immer noch einen Fehler verursachen, da die Funktion später im Code definiert würde und die Struktur nach der Funktion suchen würde.

Gibt es eine Lösung für dieses Problem mit Huhn und Ei?

Answer 1

Sie können eine Klasse "weiterleiten", so dass sie vor der vollständigen Definition entweder durch einen Zeiger oder eine Referenz referenziert werden kann.

class MyClass; // forward declaration 

void fn1(MyClass* ptr); // legal 

void fn2(MyClass* ptr) // legal 
{ 
    ptr->something; // illegal, definition of MyClass unknown 
} 

class A { 
    MyClass mc; // illegal, definition of MyClass unknown 
}; 

class MyClass { 
    // ... 
}; 

jedoch in Ihrem Beispiel, schreiben Sie folgende:

typedef struct testStructure 
{ 
    int data; 
    void *TestFunction(testStructure *tempStructValue) 
} temp; 

dies deklariert eine Klasse, testStructure, die als Integer Mitglied data und eine MemberfunktionTestFunction, die einen void* Zeiger zurückzugibt . Diese Mitgliedsfunktion hat absolut keine Verbindung zur vorherigen, freien Funktion TestFunction. Es ist unklar, was deine Absicht ist.

Beispiel:

#include <iostream> 

struct TestStructure; 

void TestFunction(TestStructure* /*unused*/) { 
    std::cout << "Free TestFunction\n"; 
} 

struct TestStructure { 
    int i; 
    void TestFunction(TestStructure* /*unused*/) { 
     std::cout << "TestStructure TestFunction\n"; 
    } 
    void foo() { 
     std::cout << "From foo\n"; 
     TestFunction(this); 
    } 
}; 

int main() { 
    std::cout << "From main:\n"; 
    TestFunction(nullptr); 

    TestStructure t; 
    t.foo(); 
} 

http://ideone.com/1453GG

Das gleiche gilt, wenn sie die andere Art und Weise erklärt werden um: http://ideone.com/VDcJxe

Dies liegt daran, Namen basierend auf Umfang gelöst werden. Member-Funktionen der Klasse/Struktur werden den eigenen Bereich der Klasse/Struktur konsultieren, bevor sie wo anders suchen. Wenn wir die freie Funktion aus dem Inneren einer Memberfunktion aufrufen wollten, könnten wir das nutzen ‚::‘ Bereichsoperator als solche:

void foo() { 
    ::TestFunction(); // resolves from the global scope 
} 

See: http://ideone.com/B51J4C (man beachte, wählte ich die Funktion zu übermitteln erklären, was wiederum erfordert dass ich forward deklariere die Klasse für ihr Argument).

Answer 2

Wenn es ein c-Code ist. Das Trennen der Datei in 3 Dateien kann das Problem lösen. Erstellen einer Header-Datei für die Struktur und eine für die Funktion wird möglicherweise Lösung. Fügen Sie die Funktion heder in die Strukturdatei ein. Dann fügen Sie struct heder in die c-Datei der Funktion ein. Aber wenn Ihr Code in C++ geschrieben ist (Cout lässt mich denken, dass es wahrscheinlicher ist), sollten Sie einige OOA, OOD versuchen und möglicherweise Entwurfsmustertechniken für die Lösung für Ihre Bedürfnisse sein.

Der Rückgabewert der Funktion muss ein Zeigertyp sein.