Variablen übergabe von CPP zu CPP funktioniert nicht

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

  • Variablen übergabe von CPP zu CPP funktioniert nicht

    Ich habe folgendes Problem:

    Ich habe eine Variable char uebergabe in der Headerdatei extern deklariert, weil ich idese in einer anderen CPP_Datei brauchte.

    Klappt alles wunderbar, nur habe ich in der 2. CPP eine variable die ich an einer dritten CPP übergeben muß.

    also wieder extern float uebergabe2; // Diese Deklaration wird in der Quell- und in der Zielheader eingebunden

    soweit so gut, die deklaration funktioniert, nur wird nichts übergeben.
    Ich habe keine Ahnung warum.. die variable wurde genauso deklariert wie zuvor, habe auch die headerdatein der anderen CPP eingebunden.

    Deklariert wird sie nur wird nichts übergeben wieso?
    Am float kann es ja nicht liegen.. // das der einzige unterschied zur anderen übergabevariable udn der variablenname logischerweise.

    Ich hoffe Sie können mir weiter helfen.
  • was heisst hier "übergeben" - sowas "tun" Funktionsaufrufe mit Parametern ... drum bin ich etwas verwirrt.
    Aber ich denke mal, du möchtest - allgemein gesagt - auf eine Variable (global) aus einem anderen Modul zugreifen, oder?

    Normalerweise macht man das in etwa so:

    C-Quellcode

    1. cpp1.cpp:
    2. /* evlt. eigenes interface includieren - wegen "whatever" nicht noetig!... */
    3. #include "cpp1.h"
    4. /* globale variable deklarieren */
    5. float whatever;
    6. cpp1.h:
    7. #ifndef CPP1_H
    8. #define CPP1_H
    9. /* bekanntmachung */
    10. extern float whatever;
    11. #endif /* CPP1_H */
    12. cpp2.cpp:
    13. /* bekanntmachung includieren */
    14. #include "cpp1.h"
    15. void function() {
    16. /* nach Herzenslust zugreifen ... */
    17. ...
    18. }
    Alles anzeigen


    Wenn man diesem Schema treu bleibt und noch dazu "Include"-Wächter in den header-files einbaut, sollte das auf jeden Fall klappen - auch bei überkreuzten includes.Hoffe, das hilft erstmal weiter ...
    grüße
    Microsoft gives you Windows, UNIX gives you the whole house.
  • Hallo und danke erstmal für die Antwort.

    allgemein gesagt - auf eine Variable (global) aus einem anderen Modul zugreifen, oder?


    Genau^^


    Normalerweise macht man das in etwa so:

    Code:

    cpp1.cpp:
    /* evlt. eigenes interface includieren - wegen "whatever" nicht noetig!... */
    #include "cpp1.h"
    /* globale variable deklarieren */
    float whatever;

    cpp1.h:
    #ifndef CPP1_H
    #define CPP1_H
    /* bekanntmachung */
    extern float whatever;
    #endif /* CPP1_H */

    cpp2.cpp:
    /* bekanntmachung includieren */
    #include "cpp1.h"
    void function() {
    /* nach Herzenslust zugreifen ... */
    ...
    }


    Genauso hab ich es ja gemacht.. aber es funktioniert leider nur bei der char variable und nicht bei der float.

    Das komische ist ja, das die Deklaration funktioniert, nur wird kein Wert mit "übergeben". Wenn die Variable bspw. in der CPP1 den Wert 2 erhält, hat sie in der CPP2 trotzdem den Wert 0..
    Ich habe diese Variable auch nicht nochmals in der CPP2 deklariert, so das dort vielleicht die Variable auf 0 gesetzt wird.

    Ich weiß nicht warum...

    Mit dem Variablentyp hat es nichts zutun das ist klar..
    aber warum es nicht funktoniert.. keine Ahnung...

    Normalerweise müsste es ja funktionieren, habe alles schon X-mal überprüft, habe nichts vergessen zu includen oder global zu deklarieren...
  • Hier mal die entsprechenden Codeauszüge:



    //----UTicketauswahl3.cpp----
    ...
    float tempkost, Preis, Anzahl, uebergabe2;
    ...
    uebergabe2=Preis;
    ...

    //---UTicketauswahl3.h---
    #ifndef UTicketauswahl3H
    #define UTicketauswahl3H
    .....
    extern float uebergabe2;
    ..
    #endif

    //----USimulator5.cpp------
    ..
    #include "UTicketauswahl3.h"
    ...

    __fastcall TForm5::TForm5(TComponent* Owner)
    : TForm(Owner)
    {
    Lkost->Caption=FloatToStrF(uebergabe2,ffNumber,3,2)+ " €";
    }
    ...




    Ausgegeben wird 0 € egal welchen Wert uebergabe2 in der UTicketauswahl3.cpp erhält.
  • Alle so ratlos wie ich??

    Ich poste mal den Code von der char Variable, mit der es funktioniert.
    Vielleicht endeckt ja jmd unterschiede, bis auf den Variablentyp und den Namen^^

    Quellcode

    1. //-----UTicketAut1.cpp------
    2. char Preisstufe, uebergabe;
    3. //...
    4. uebergabe=Preisstufe;
    5. //..
    6. //---UTicketAut1.h---------
    7. #ifndef UTicketAut1H
    8. #define UTicketAut1H
    9. //...
    10. extern PACKAGE TForm1 *Form1;
    11. extern char uebergabe;
    12. //----
    13. #endif
    14. //------UTicketauswahl3.cpp---------
    15. #include "UTicketAut1.h"
    16. //...
    17. if (Reinzel->Checked)
    18. {
    19. switch (uebergabe)
    20. {
    21. case 'A': tempkost=2; break;
    22. case 'B': tempkost=3.8; break;
    23. //....
    Alles anzeigen


    Dies funktioniert.. Ich erkenne keinen unterschied bzw. irgendwas was ich beim obriegen Code vergessen habe..
  • Hi,
    hmm - da bin ich erstmal platt ... ;) - sieht OK aus!
    Allerdings würd ich aufgrund deiner Beschreibung vermuten, dass sich da irgendwie ein "extern" verflüchtigt hat oder wie auch immer - jedenfalls gibts die Variable scheinbar zweimal.
    Wo ich mir auch nicht sicher bin, ist die globale Initialisierung, die du da machst. Hier kann man leider nie wirklich sicher sein, wann die durchgeführt wird - und standardmäßig sind globale Variablen ja 0 ... verdächtig! Kannst du die Initialisierung nicht - entweder per fixem Wert machen oder irgendwo in ner Funktion main/Constructor unterbringen?
    Versuch mal, aus beiden Modulen auf die Variable zuzugreifen - und: lass mal die Adresse ausgeben, dann weisst dus sicher obs ein und die selbe Variable ist. Ausgabe z.B. ganz schnell und dreckig per

    Quellcode

    1. printf( "%d\n", &uebergabe2 ); // cast-gemecker ignorieren wir hier mal ;)


    grüße
    Microsoft gives you Windows, UNIX gives you the whole house.