variable global verfügbar machen

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • variable global verfügbar machen

    Hi ich hab erstelle in einer Funktion ein dynamisches array welches ich dann noch in anderen Funktionen nutzen will... wie geht das? static? extern? public? ich blick da net durch

    Hier is mal der Quelltext so wie es prinzipiell funktionieren soll(code wurde nicht auf fehler geprüft soll ja au nur nen Beispiel sein

    Quellcode

    1. void funktion()
    2. {
    3. int a = 10;
    4. String* test = new String[a];
    5. }
    6. cout << test[2].c_str() << endl;


    Kann mir da jemand helfen??

    MfG Straightflush

  • Du kannst einfach den pointer auf das array übergeben:

    Quellcode

    1. string* funktion()
    2. {
    3. int a = 10;
    4. string* test = new string[a];
    5. test[2] = "hallo";
    6. return test;
    7. }
    9. string* pointer_auf_test = funktion();
    10. cout << pointer_auf_test[2].c_str() << endl;
    11. pointer_auf_test[3] = "huhu";
    12. cout << pointer_auf_test[3].c_str() << endl;
    Alles anzeigen

    Der standard-string wird in C übrigens kleingeschrieben.

    Edit: Ich weiss aber nicht ob das die feine Art ist...Funktionieren tuts jedenfalls ;)

  • Natürlich gibts globale Variablen, das sind Variablen, die nicht in einer Funktion deklariert werden.

    Quellcode

    1. #include <iostream>
    2. int i = 5; // überall gültig
    3. int main(){
    4. std::cout << i;
    5. return 0;}

    Aber von globalen Variablen ist abzuraten, weil das bei größeren Programmen einfach zu unübersichtlich wird.
    Gewöhn dir lieber von vornherein an ohne globale Variablen zu arbeiten.

    Ahh, jetzt versteh ich was du wolltest...alles nich so einfach heute.
    Ja, das machst du mit "extern". Aber nur wenn du die Variable in mehreren Dateien benutzen musst.
    Nehmen wir an du hast eine globale Variable wie oben.
    Um diese auch in anderen Modulen/Dateien deines Programmes zu verwenden musst du "extern int i;" benutzen und kannst dann innerhalb des Moduls drauf zugreifen.
    Aber es gibt ne Menge Seiten die das viel ausführlicher behandeln. z.B. diese hier

  • hab jetzt mal nen genauen Code geschrieben...
    Die Fehlermeldung die ich bekomme ist: Undefiniertes Symbol "foo"

    Quellcode

    1. //---------------------------------------------------------------------------
    3. #include <vcl.h>
    4. #pragma hdrstop
    5. #include <iostream>
    6. #include <conio.h>
    7. using namespace std;
    9. //---------------------------------------------------------------------------
    11. #pragma argsused
    12. void test(int i)
    13. {
    14. String* foo = new String[i];
    15. foo[2] = "hallo";
    16. }
    17. int main(int argc, char* argv[])
    18. {
    19. test(10);
    20. cout << foo[2]; // <----------- FEHLERZEILE
    21. system("PAUSE");
    22. return 0;
    23. }
    24. //---------------------------------------------------------------------------
    Alles anzeigen


    vll wird jetzt klarer was ich gemeint habe...
    ich habe jetzt aber keine ahnung wo ich des "extern" hinsetzen soll...

    Kann mir jemand helfen??? ich hab echt keine Ahnung was ich jetzt noch machen kann... Die Funktion erstellt ein array von vorher unbestimmter größe und diese array soll nachher im gesamten Programm verfügbar sein... mit einem einfachen Rückgabewert scheint das nicht zu gehen

  • Du könntest einen globalen zeiger erstellen den du dann später auf den Anfang des Arrays zeigen lässt:

    Quellcode

    1. //---------------------------------------------------------------------------
    3. #include <vcl.h>
    4. #pragma hdrstop
    5. #include <iostream>
    6. #include <conio.h>
    7. using namespace std;
    8. String* foo = NULL; // Zeiger global verfügbar
    10. //---------------------------------------------------------------------------
    12. #pragma argsused
    13. void test(int i)
    14. {
    15. foo = new String[i]; // Zeiger zeigt auf den Anfang des string arrays
    16. foo[2] = "hallo";
    17. }
    18. int main(int argc, char* argv[])
    19. {
    20. test(10);
    21. cout << foo[2]; // <----------- FEHLERZEILE
    22. system("PAUSE");
    23. return 0;
    24. }
    25. //---------------------------------------------------------------------------
    Alles anzeigen

    Aber was für einen compiler benutzt du?
    std::String ist mir unbekannt.

  • Du musst nirgends ein "extern" hinsetzen.
    Variablen haben eine Sichtbarkeit (im engl. Scope). Der Scope der Variablen "foo" ist die Funktion "test" d.h. dass du nur innerhalb dieser Funktion darauf zugreifen kannst.
    Kurzes Bsp dazu:

    Quellcode

    1. function test1 () {
    2. int i = 5;
    3. cout << i << endl;
    4. }
    5. function test2 () {
    6. int i = 7;
    7. cout << i << endl;
    8. }
    9. int main () {
    10. test1 ();
    11. test2 ();
    12. return 0;
    13. }
    Alles anzeigen

    -> das Ergebnis sollte sein, dass zuerst eine 5 ausgegeben wird und danach eine 7, und dass, obwohl beide Variablen "i" heißen. Das "i" in "test1" weiß aber nicht, dass es ein "i" in "test2" gibt.
    Das löst dein Problem noch nicht, aber es hilft hoffentlich bei der Erklärung.
    Wenn du also in deinem Proggy willst, dass foo auch im "main" bekannt ist, hast du 2 Möglichkeiten:
    1.) die bereits erwähnten globalen Variablen, von denen aber im großen Stile abgeraten wird oder
    2.) einen Rückgabewert (Returnvalue auf neudeutsch).
    Spielen wir mal Variante 2 für dein Beispiel durch:
    Derzeit gibt die Funktion "test" nichts zurück (void). Du möchtest aber, dass sie das "String" array zurückliefert. Daher musst du den Returntyp auf "String*" ändern. Nur dadurch sagst du deinem Programm noch immer nicht, welche Werte zurückkommen, sondern nur, welcher Typ. Um auch einen Wert zurückzuliefern, musst du daher das "return" Schlüsselwort verwenden: "return foo;". Damit sagst du dem Compiler: hallo lieber Compiler, ich will den Wert von "foo" noch an anderer Stelle verwenden.
    Damit ist dein Problem aber noch immer nicht 100%ig gelöst. Es fehlt noch eine Variable im "main", die den zurückgelieferten Wert entgegen nimmt. Um Dir gleich nochmal den Scope nahezu bringen, würde ich Dir empfehlen, die Variable im "main" anders zu benennen (auch um zu zeigen, dass die Variablen nicht gleich heißen müssen):

    Quellcode

    1. String* pStringArray;

    Jetzt noch die Zuweisung, und wir sind fast fertig:

    Quellcode

    1. pStringArray = test (10);

    Jetzt musst du bei der Ausgabe noch beachten, dass du dort nicht "foo[2]" ausgibst, sondern "pStringArray[2]", aber das versteht sich nach der Erklärung hoffentlich von selbst :)

    In C++ it es wichtig, dass jeder Speicher der angelegt wurde auch wieder freigegeben wird, da es sonst zu sog. Speicherleaks kommt. Hierbei muss unterschieden werden, ob du ein Array angelegt hast, oder eine "einfache" Variable. Für Arrays, egal welcher Größe, musst du "delete [] variable;" aufrufen (Ausnahme: char Arrays (char* oder char[])), für einfache Pointer nur "delete variable;". In deinem Beispiel musst du also

    Quellcode

    1. delete [] pStringArray;

    vor dem "return 0;" ausführen.

    Um das mit dem Speicherleak auszuprobieren, mach einfach folgendes: führe das untere Programm aus, warte eine Zeitlang, und irgendwann wird dir der Rechner langsam werden und er wird dir sagen "out of memory":

    Quellcode

    1. int main () {
    2. char *p = NULL;
    3. while (1) // Endlosschleife
    4. {
    5. p = new char [8192]; // jedes Mal 8 Kilobyte allokieren
    6. // mach was mit p
    7. }
    8. return 0; // wird nie erreicht
    9. }


    Das folgende Programm wiederrum löscht den Speicher wieder den es nicht braucht und rennt daher ewig (bzw. bis zum nächsten Stromausfall) und kann nur mit "Strg"+"C" abgeschossen werden:

    Quellcode

    1. int main () {
    2. char *p = null;
    3. while (1) // Endlosschleife
    4. {
    5. p = new char [8192]; // jedes Mal 8 Kilobyte allokieren
    6. // ... mach was mit p
    7. delete p; // Ausnahme von Array delete!!
    8. }
    9. return 0; // wird nie erreicht
    10. }


    So genug der Worte und viel Erfolg