Frage zur globalen Variable in Funktion mit Boost Options



  • Guten Abend, Alle

    Ich möchte einfach eine globale Variable in einer lokalen Funktion überschreiben und dann wieder in der anderen Funktion mit einer anderen Variable, die man in Terminal gibt, addieren.

    Wie kann ich diese globale Variable (ich meine immer aktualisiert) mit neuen gegebenen Wert in die andere Funktion addieren, wie mache ich denn es mit boost options ???

    Vielen Dank! LG

    Code:

    #include <fstream>   
    #include <boost/shared_ptr.hpp>   
    #include <boost/make_shared.hpp>   
    #include <boost/log/core.hpp> 
    #include <boost/log/common.hpp> 
    #include <boost/log/trivial.hpp>   
    #include <boost/log/expressions.hpp>   
    #include <boost/log/sinks/sync_frontend.hpp>   
    #include <boost/log/sinks/text_ostream_backend.hpp>   
    #include <boost/log/sources/severity_logger.hpp>   
    #include <boost/log/sources/record_ostream.hpp>   
    #include <boost/log/utility/setup/common_attributes.hpp> 
    #include <boost/log/utility/setup/file.hpp> 
    #include <boost/log/support/date_time.hpp>   
    #include <boost/thread/thread.hpp>   
    #include <boost/log/attributes/scoped_attribute.hpp> 
    #include <boost/program_options.hpp> 
    #include <stdio.h>
    #include <iostream> 
    #include <string.h> 
    
    //using namespace boost::algorithm; 
    using namespace std; 
    using namespace boost::program_options; 
    //using namespace boost::log; 
    
    namespace logging = boost::log; 
    namespace sinks = boost::log::sinks; 
    namespace expr = boost::log::expressions; 
    namespace src = boost::log::sources; 
    namespace triv = logging::trivial;
    
    int vara = 0;
    
    void set_global_var(int inputa){
    
    	vara = inputa;
    
    }
    
    void calcu(int inputb){
    
    	int res;
    
    	res = vara + inputb;
    
    	printf("Add: %d \n", res);
    
    }
    
    int main(int argc, const char *argv[]) 
    { 
        //init();  
       //using namespace logging::trivial; 
       //src::severity_logger< severity_level > lg; 
    
       //create boost help options
    
       try 
       { 
    	    options_description desc{"Options"}; 
    
    	    desc.add_options() 
    		    ("help,h", "Help screen")
    		    ("log-add,v", value<int>()->notifier(calcu), "input for add.")
    		    ("log-var,v", value<int>()->notifier(set_global_var), "Set global variable in function.");
    
    	    printf("global var: %d \n", vara);
    
    	    variables_map vm; 
    	    store(parse_command_line(argc, argv, desc), vm); 
    	    notify(vm); 
    
    	    if(argc < 2 || argc > 10){ 
    
    		    std::cout << desc << '\n'; 
    	    }else{
    
    		if (vm.count("help")){ 
    
    		    std::cout << desc << '\n'; 
    
    		}else if (vm.count("log-var")){ 
    		        std::cout << "set global var : " << vm["log-var"].as<int>() << '\n'; 
    
    		}else if (vm.count("log-add")){ 
    		        std::cout << "input value : " << vm["log-add"].as<int>() << '\n'; 
    
    		}else{
    
    			std::cout << desc << '\n';
    		}
    
    	    } 
    
       }catch (const error &ex) 
       { 
            std::cerr << ex.what() << '\n'; 
       }
        return 0; 
    
    }
    

  • Mod

    hanowde schrieb:

    Wie kann ich diese globale Variable (ich meine immer aktualisiert) mit neuen gegebenen Wert in die andere Funktion addieren, wie mache ich denn es mit boost options ???

    Wo besteht denn der Zusammenhang zwischen globalen Variablen* und boost options? Was ist dein Problem?

    Wenn du die Grammatik deines Beitrags verbessern würdest, könnte man vielleicht etwas mehr über deine Absichten erraten, aber leider verwirrt dein Satzbau den Leser mehr, als dass er hilft.

    *: Globale Variablen sollten sowieso niemals benutzt werden. Dein Fall ist keine der seltenen Ausnahmen, wo es sich nicht vermeiden lässt, sondern geradezu das Paradebeispiel, wofür man keine globalen Variablen nutzen sollte.



  • Es tut mir leid für die schlechte Formulierung meiner Problembeschreibung.

    Ich möchte die Optionen für die Argumente bei der Ausführung so festlegen wie folgendes:

    ./program -v 10 -a 5

    dann bekomme ich als Ergebnis 15.

    -v: für die Funktion der 10 übergibt, und in der Funktion einer variable zuweist.

    -a: für die Funktion der Addition vom Parameter 5 und der Variable, die ich als erste Zahl (z.b -v 10) angegeben habe.

    Wie mache ich am besten, dass in der Funktion der Addition die erste Eingabe (im Fall 10) mit zweiter Eingabe 5 addiert...?

    Sorry, ich bin verwirrt...
    Danke sehr!

    LG, Carvin


  • Mod

    *: Globale Variablen sollten sowieso niemals benutzt werden.

    Das ist selbst als Faustregel für Anfänger mMn. nicht sinnvoll.


  • Mod

    hanowde schrieb:

    Wie mache ich am besten, dass in der Funktion der Addition die erste Eingabe (im Fall 10) mit zweiter Eingabe 5 addiert...?

    Und wieso müssen dazu globale Variablen genutzt werden?

    Du hast immer noch nicht gesagt, was dein Problem dabei ist. Hast du Schwierigkeiten bei der Benutzung von boost options oder ist es ein anderes Problem?

    Arcoth schrieb:

    *: Globale Variablen sollten sowieso niemals benutzt werden.

    Das ist selbst als Faustregel für Anfänger mMn. nicht sinnvoll.

    Willst du auf solche Klugscheißerfälle hinaus, wie dass cout eine globale Variable ist? Wo braucht ein Anfänger denn jemals eine globale Variable?



  • Ich hoffe dass du verstehst was mein Programm tut?

    Wenn du magst, du kannst es ausführen und dann siehst du welches Problem ich habe.

    Im Ternminal gebe ich :

    ./myprogram -v 10 -a 5 sollte dann 10+5 = 15 ausgeben.

    Aber das Ergebnis ist 5, warum?

    Danke, LG


  • Mod

    Erstens mal sollte das Programm in dem Fall einen Fehler ausgeben, weil du das 'v' doppelt belegt hast, aber kein 'a' angegeben hast:

    ("log-add,v", value<int>()->notifier(calcu), "input for add.")
                ("log-var,v", value<int>()->notifier(set_global_var), "Set global variable in function.");
    

    Zweitens ist das genau eine der Folgen von globalen Variablen: Du hast die Kontrolle über den Programmfluss verloren. Wenn du mal die Zeile 69 in die set_global_var funktion verlegst, wirst du sehen, was passiert: calcu wird vor set_global_var aufgerufen!

    Der Grund dafür wird wohl sein, dass "log-add,v" im Alphabet vor "log-var,v" kommt. Der eigentliche Grund ist aber, dass das Programm so gestaltet ist, dass es überhaupt auf die Reihenfolge ankommt. Ich vermute mal, dass dies alles ein stark vereinfachtes Beispiel für dein eigentliches Problem ist, daher ist es schwierig, konkrete Tipps zu geben, wie es besser ginge.


  • Mod

    SeppJ schrieb:

    Arcoth schrieb:

    *: Globale Variablen sollten sowieso niemals benutzt werden.

    Das ist selbst als Faustregel für Anfänger mMn. nicht sinnvoll.

    Willst du auf solche Klugscheißerfälle hinaus, wie dass cout eine globale Variable ist? Wo braucht ein Anfänger denn jemals eine globale Variable?

    E.g. Tags zum Dispatchen. Oder eine Konstante. So Zeugs halt.

    Edit: Was hat das mit Anfängern zu tun? Es ist bei derartigen "Fallen" besser, zu erklären, dass die Verwendung als Anfänger zu unterlassen ist, jedoch nicht per se schlecht. So wie mit goto .



  • Danke für deine Antwort.

    Du hast richtig vermutet, das ursprüngliche Programm tut ein bisschen anders als dieses einfache Version.

    Aber ob -v vor -a oder umgekehrt in Programm Option steht spielt keine Rolle, denke ich, weil ich bei der Ausführung sowieso erst -v dann -a mache.

    Und das mit dem Get-Set-Methode habe ich auch schon im ursprünglichen Programm ausprobiert, es gab mir das gleiche aus, dass in diesem Beispiel nicht die 10 sondern 0 + 5 = 5 gemacht hat...

    Ich brauche eure Ideen & Tipps !

    Vielen Dank im Voraus.

    LG


  • Mod

    hanowde schrieb:

    Aber ob -v vor -a oder umgekehrt in Programm Option steht spielt keine Rolle, denke ich, weil ich bei der Ausführung sowieso erst -v dann -a mache.

    Lies meine Antwort noch einmal genau. Die Reihenfolge bei der Ausführung spielt keine Rolle.

    Aber selbst wenn du dies umdrehst, ist dies keine wirkliche Lösung und zudem höchst unbefriedigend. Leider hast du nur bestätigt, dass deine eigentliche Problemstellung eine komplexere ist, aber nicht erklärt, was diese denn nun ist. Daher kann man dir nach wie vor nicht wirklich weiter helfen, außer den Fehler zu erklären. Und das ist ja bereits erfolgt.



  • Hi, SeppJ

    Danke nochmal für deine Antwort.

    Meine Frage wäre, wie kann ich eine Variable die ich in einer Funktion übergeben habe, in der zweiten Funktion in meinem Programm weiter verwenden?

    Wie mache ich das Variablen-Transfer zw. Funktionen in einem Programm?

    Danke sehr.



  • Arcoth schrieb:

    SeppJ schrieb:

    Arcoth schrieb:

    *: Globale Variablen sollten sowieso niemals benutzt werden.

    Das ist selbst als Faustregel für Anfänger mMn. nicht sinnvoll.

    Willst du auf solche Klugscheißerfälle hinaus, wie dass cout eine globale Variable ist? Wo braucht ein Anfänger denn jemals eine globale Variable?

    E.g. Tags zum Dispatchen. Oder eine Konstante. So Zeugs halt.

    Niemand hat etwas gegen globale Konstanten. Globaler State ist böse und den fängt man sich mit globalen Variablen ein.


  • Mod

    zeugs schrieb:

    Arcoth schrieb:

    SeppJ schrieb:

    Arcoth schrieb:

    *: Globale Variablen sollten sowieso niemals benutzt werden.

    Das ist selbst als Faustregel für Anfänger mMn. nicht sinnvoll.

    Willst du auf solche Klugscheißerfälle hinaus, wie dass cout eine globale Variable ist? Wo braucht ein Anfänger denn jemals eine globale Variable?

    E.g. Tags zum Dispatchen. Oder eine Konstante. So Zeugs halt.

    Niemand hat etwas gegen globale Konstanten. Globaler State ist böse und den fängt man sich mit globalen Variablen ein.

    Ich habe keine Ahnung was für eine Definition von Variable du verwendest, aber wir machen hier kein Mathe.



  • Dir ist bekannt, dass es bei Boost Program Options auch noch andere Möglichkeiten als über notify Funktion gibt, um an die Variablen zu kommen?

    #include <boost/program_options.hpp>
    #include <iostream>
    
    namespace po = boost::program_options;
    
    int main(int argc, char **argv)
    {
      int add, value;
      po::options_description desc("Options");
      desc.add_options()
        ("help,h", "Help screen")
        ("log-add,a", po::value<int>(&add)->required(), "input for add.")
        ("log-var,v", po::value<int>(&value)->required(), "Set global variable in function.");
    
      po::variables_map vm;
      po::store(po::parse_command_line(argc, argv, desc), vm);
      po::notify(vm);
    
      std::cout << value + add << std::endl;
    }
    


  • Hi,

    Vielen Dank für eure Antwort.

    Ich habe zu dem Problem falsch gedacht. Jetzt habe ich mehr über die Verwendung von options verstanden.

    Ein ähnliches Programm wie das von sebi707 habe ich als Beispiel geschrieben.

    Schönen Tag.

    LG


Anmelden zum Antworten