Partage
  • Partager sur Facebook
  • Partager sur Twitter

problème paramètre fonction main

    7 novembre 2021 à 4:04:08

    bonjour je suis en train de creer un deux programes qui sont censées communiquer via les parametres de la fonction main, et j'ai un probleme:

    dans le second programe je compare un argument avec une chaine de charactère, comme je le fais habituelement, mais cette fois,  bien qu'il n'y ait pas de différence entre la chaine de charactère et le parametre, mon programe ne m'affiche pas ce qu'il est censé afficher. je vois pourtant que le programme s'execute car j'ai rajouté des ligne qui sont censé afficher e paramètre argv[1] et il est afficher.

    cela fais trois jour que je teste des changements et que je cherche un résolution pour ce probleme donc je vien voir si la communauté pourrais m'aider.

    merci d'avances pour vos réponses.

    voici le code:

    programe SETUP:

    #include <iostream>
    #include <SFML/Graphics.hpp>
    
    using namespace sf;
    
    //function definitions
    void startGame(std::string params) {
        std::string cmd = "./SSSSLIME " + params;
        //debug
        std::cout << cmd << " ; " << cmd.c_str() << std::endl;
        //debug*/
        system(cmd.c_str());
    }
    
    //colors references
    namespace SColors {
        //app
        const Color AppBackground(20, 22, 25);
        //buttons
        const Color BtnBackground(230, 230, 230);
        const Color BtnBackgroundRect(200, 200, 200);
        const Color BtnText(50, 50, 50);
    }
    
    //button class
    class buttons {
    private:
    //integers
        int x, y, heigh, width;
    //string
        std::string name;
        //sfmls
        //rectangle
        RectangleShape btnRect, backgroundRect;
        //texts
        Text btnText;
        //font
        Font btnFonts;
    public:
    //constructor
        buttons(int x, int y, int heigh, int width, std::string text, std::string name);
    
    //functions
        void onClick(RenderWindow &app);
        void draw(RenderWindow &app);
    
    };
    
    void buttons::onClick(RenderWindow &app) {
        if(Mouse::getPosition(app).x > this->x && Mouse::getPosition(app).x < this->x + this->width && Mouse::getPosition(app).y > this->y && Mouse::getPosition(app).y < this->y + this->heigh) {
            /*/debug
            std::cout << "getPosition() : " << Mouse::getPosition().x << " ; " << Mouse::getPosition().y << std::endl;
            std::cout << "getPosition(app) : " << Mouse::getPosition(app).x << " ; " << Mouse::getPosition(app).y << std::endl;
            std::cout << "x : " << this->x << " ; " << this->x + this->width << std::endl;
            std::cout << "y : " << this->y << " ; " << this->y + this->heigh << std::endl;
            //debug*/
            if (this->name == "fullscreen" || this->name == "window") {
                app.close();
                startGame(this->name);
            }
        }
        return;
    }
    
    buttons::buttons(int x, int y, int heigh, int width, std::string text, std::string name) : x(x), y(y), heigh(heigh), width(width), name(name) {
        //btnRect
        this->btnRect = RectangleShape(Vector2f(this->width - 10, this->heigh - 10));
        this->btnRect.setFillColor(SColors::BtnBackground);
        this->btnRect.setPosition(x + 5, y + 5);
        //BackgroundRect
        this->backgroundRect = RectangleShape(Vector2f(this->width, this->heigh));
        this->backgroundRect.setFillColor(SColors::BtnBackgroundRect);
        this->backgroundRect.setPosition(x, y);
        //btnFont
        this->btnFonts.loadFromFile("setup/fonts/buttons.otf");
        //btnText
        this->btnText = Text(text, this->btnFonts);
        this->btnText.setPosition(x + 10, y);
        this->btnText.setFillColor(SColors::BtnText);
    }
    
    void buttons::draw(RenderWindow &app) {
        app.draw(this->backgroundRect);
        app.draw(this->btnRect);
        app.draw(this->btnText);
    }
    
    int main() {
        //strings
        std::string title = "SSSSLime";
        //main app
        RenderWindow app(VideoMode(500, 300), title + " setup", sf::Style::Close);
        //buttons
        buttons fullscreen(70, 125, 50, 150, "Fullscreen", "fullscreen");
        buttons windows(280, 125, 50, 150, "Window", "window");
        //font
        Font titleFont;
        titleFont.loadFromFile("setup/fonts/buttons.otf");
        //texts
        Text titleText(title, titleFont);
        titleText.setPosition(200 , 0);
        titleText.setFillColor(Color(0, 255, 0));
    
        /*/debug
        int x, y;
        //debug*/
    
        //mainloop
        while(app.isOpen()) {
            Event e{};
            while(app.pollEvent(e)) {
                if (e.type == Event::Closed)
                    app.close();
                if(e.type == Event::MouseButtonPressed) {
                    /*/debug
                    std::cout << Mouse::getPosition(app).x << " ; " << Mouse::getPosition(app).y << std::endl;
                    //debug*/
                    if (e.mouseButton.button == Mouse::Button::Left) {
                        fullscreen.onClick(app);
                        windows.onClick(app);
                    }
                }
            }
    
            app.clear(SColors::AppBackground);
            /*/debug
            app.clear(SColors::BtnText);
            //debug*/
    
            //------Update------//
    
            /*/debug
            if (x != Mouse::getPosition().x && y != Mouse::getPosition().y) {
                std::cout << "getPosition() : " << Mouse::getPosition().x << " ; " << Mouse::getPosition().y << std::endl;
                std::cout << "getPosition(app) : " << Mouse::getPosition(app).x << " ; " << Mouse::getPosition(app).y << std::endl;
            }
            x = Mouse::getPosition().x;
            y = Mouse::getPosition().y;
            //debug*/
    
            fullscreen.draw(app);
            windows.draw(app);
            app.draw(titleText);
    
            //------Update------//
    
            app.display();
        }
        return 0;
    }
    

    programe SSSSLIME:

    //
    // Created by Strong21 on 30/10/2021.
    //
    #include <iostream>
    
    using namespace std;
    
    int main(int argc, char *argv[]) {
        /*/debug
        cout << argv[0] << argv[1] << endl;
        //debug*/
        if(argc < 2)
            cerr << "ERROR : use a parameter : -p <PARAMETER>" << endl;
        //debug
        cout << argv[1] << endl;
        //debug*/
        if (argv[1] == "fullscreen")
            cout << "mode : " << argv[1] << endl;
        else if (argv[1] == "window")
            cout << "mode : " << argv[1] << endl;
        return 0;
    }
    



    • Partager sur Facebook
    • Partager sur Twitter
      7 novembre 2021 à 11:49:25

      Salut,

      Héhé... à, tu ne compare pas deux chaines ds caractères, comme tu le crois, mais bien deux ... pointeurs de types char, qui représentent donc l'adresse du premier caractère de la chaine.

      Or, comme arv[1] (qui représente donc l'adresse à  laquelle se trouve le deuxième argument de ton programme, le premier étant son nom est donné par l'utilisateur.

      D'un autre coté, "fullscreen" et "window" étant des chaines de caractères littérales, elles sont connues et clairement établies à la compilation et vont donc se retrouver dans une zone bien précise de ton exécutable final.

      Il n'y a donc absolument aucune chance pour que les adresses mémoires (qui ne sont que des valeurs numériques entières généralement non signées) correspondent.

      Tu ne dois donc pas comparer les deux pointeurs comme tu le fais, mais bien comparer ... la donnée qui commence à l'adresse représentée par ces deux pointeurs.

      Pour ce faire, tu  dois utiliser strcmp ou strncmp.

      Ceci étant dit, la représentation d'une chaine de caractères sous la forme d'un pointeur sur un caractère (typiquement un char * ) et la représentation classique des chaines en C, qui est avantageusement gérée par la classe std::string.

      Si tu n'as pas trop de paramètres susceptibles d'arriver dans ta lignes de commande, tu peux toujours les convertir en chaines de caractères sous la forme de

      std::string mode{argv[1]};
      
      /* puis la comparaison */
      if(mode =="fullscrean")
          /* ... */
      else if (mode =="window")
          /* ... */
      

      Si tu  en as un peu plus, tu serais peut-être bien inspiré de travailler avec un std::vector et des std::string_viewsous une forme qui ressemblerait alors à quelque chose comme

      /* la récupération */
      std::vector<std::string_view>> params;
      for(size_t i=1;i<arvc;++i){ // je ne prend pas le premier paramètre
                                  // qui est le nom du programme et
                                  // ne m'intéresse pas
          params.push_back(std::string_view{argv[1]});
      
      }
      /* plus loin tu pourras les utiliser sous une forme proche de 
       */
      /*cherchons si un des paramètres correspond */
      for(auto & it : params){
          if(it == "salut")
              std::cout<<"trouvé salut";
      }

      Et, dans le pire des cas (de nombreux paramètres à gérer), peut-être devrais tu envisager de te tourner vers boost::program_options.

      • Partager sur Facebook
      • Partager sur Twitter
      Ce qui se conçoit bien s'énonce clairement. Et les mots pour le dire viennent aisément.Mon nouveau livre : Coder efficacement - Bonnes pratiques et erreurs  à éviter (en C++)Avant de faire ce que tu ne pourras défaire, penses à tout ce que tu ne pourras plus faire une fois que tu l'auras fait
        7 novembre 2021 à 16:36:48

        Bonjour,

        Comme la comparaison de 2 pointeurs sur des char n'est pas la comparaison des chaines, on peut utiliser le fait qu'une std::string_view est quant à elle comparable à un pointeur sur des char

        #include <iostream>
        #include <string_view>
          
        int  main( int argc, char *argv[] ) {
            
            if ( argc < 2 ) {
                endl( std::cerr << "ERROR : use a parameter : -p <PARAMETER>");
                return -1;
            }
        
            using namespace std::literals; // là on peut avantageusement utiliser using namespace
        
            if ( argv[1] == "fullscreen"sv )
                endl( std::cout << "mode : " << argv[1] );
            else if ( argv[1] == "window"sv )
                endl( std::cout << "mode : " << argv[1] );
        }
        • Partager sur Facebook
        • Partager sur Twitter

        En recherche d'emploi.

        problème paramètre fonction main

        × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
        • Editeur
        • Markdown