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;
}

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.

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] );
}