Contenu | Rechercher | Menus

Annonce

DVD, clés USB et t-shirts Ubuntu-fr disponibles sur la boutique En Vente Libre

Si vous avez des soucis pour rester connecté, déconnectez-vous puis reconnectez-vous depuis ce lien en cochant la case
Me connecter automatiquement lors de mes prochaines visites.

À propos de l'équipe du forum.

#1 Le 15/09/2020, à 15:05

lanfust

Utiliser un programme en c++ sur un autre pc

Bonjour,

Je voulais savoir comment utiliser un programme écrit en c++ sur un autre pc.

J'ai compilé ce programme sur un pc avec Ubuntu-Mate et je voulais l'utiliser sur un autre pc avec Ubuntu 20.04

Quand je lance le fichier binaire sur le 2ème pc j'obtiens ceci :

./usb_boot: 1: ELF,@hR@8: not found
./usb_boot: 2: : not found
./usb_boot: 2: BE4lsWqX=׬vT<Yy
                                           @& 
                                                    )W
                                                        n,0Y/B$2M#5-4x3-,+"*o ,.5(	g 
 \-YFE4A0)2?0#}, !$n
                              4"4L*2!z!#G)|4
j".+k	" R-
: not found    
,y044f: not found
./usb_boot: 3: Syntax error: ")" unexpected

Je compile avec la commande suivante :

g++ -std=c++17 main.cpp src/usb_boot.cpp -lstdc++fs -I include -o usb_boot `pkg-config gtkmm-3.0 --cflags --libs`

Hors ligne

#2 Le 15/09/2020, à 15:15

NicoApi73

Re : Utiliser un programme en c++ sur un autre pc

Bonjour,

As tu recompilé ce programme sur le second PC?

Hors ligne

#3 Le 15/09/2020, à 15:24

lanfust

Re : Utiliser un programme en c++ sur un autre pc

Non.
Mais je viens d'essayer et il compile avec la même commande.
Et là je peux l'utiliser.

Hors ligne

#4 Le 15/09/2020, à 15:33

NicoApi73

Re : Utiliser un programme en c++ sur un autre pc

Peux tu donner le code source?

Hors ligne

#5 Le 15/09/2020, à 17:53

lanfust

Re : Utiliser un programme en c++ sur un autre pc

voici

main.cpp

#include "usb_boot.h"



int main(int argc, char*argv[])
{
    if(std::experimental::filesystem::exists("/mnt/usb")){
        system("sudo umount /mnt/usb");
       std::experimental::filesystem::remove("/mnt/usb");
    }
    if(std::experimental::filesystem::exists("/mnt/win")){
        system("sudo umount /mnt/win");
        std::experimental::filesystem::remove("/mnt/win");
    }
    if(std::experimental::filesystem::exists("usb.txt")){
        std::experimental::filesystem::remove("usb.txt");
    }
    Gtk::Main app(argc, argv);
    usb_boot usbKey;
    Gtk::Main::run(usbKey);

    return 0;
}

usb_boot.cpp

#include "usb_boot.h"

usb_boot::usb_boot():
boiteH(true, 10), boiteV(true, 10),
boutonQ(Gtk::Stock::QUIT), boutonOk(Gtk::Stock::OK), ouvrirFichier("Fichier iso"),
groupe(), fat32(groupe, "fat32"), ntfs(groupe, "NTFS"), ext4(groupe, "ext4"),
listeDeroulante()

{

    resize(320,220);
    set_border_width(10);
    set_title("Création clef usb_bootable");
    set_position(Gtk::WIN_POS_CENTER);

/*
    listeDeroulante.append("usb1");
    listeDeroulante.append("usb2");
    listeDeroulante.append("usb3");
*/
    if ("usb.txt"){
        std::remove("usb.txt");
    }
    system ("lsblk -dPo tran,label,model,size,path | grep usb | awk '/sd/' | sed 's/\"//g'>> usb.txt");
    std::string usbFile("usb.txt"), ligneTemp;
    std::vector <std::string> usb;
    int i = 0;
    listeDeroulante.append("Choisir une clé usb");
    std::ifstream file(usbFile.c_str(), std::ios::in);
    if(file){

        while (getline(file, ligneTemp)){

            usb.push_back(ligneTemp);
            std::cout << i+1 << " " << usb[i] << std::endl;
            listeDeroulante.append(usb[i]);
            i++;

        }
    }
    else {
        std::cout << "Fichier usb.txt fermé" << std::endl;
    }

    //listeDeroulante.set_active_text("Choisir une clé usb"); //Modifier le texte présentement vu.
    if(std::experimental::filesystem::is_empty("usb.txt")){
        listeDeroulante.append("Pas de clé usb");
        listeDeroulante.set_active(1);
    }
    else{
        listeDeroulante.set_active(0);
        listeDeroulante.signal_changed().connect(sigc::mem_fun(*this, &usb_boot::afficher));
    }


    fat32.set_active(true);
    fat32.signal_clicked().connect(sigc::mem_fun(*this, &usb_boot::format));
    ntfs.signal_clicked().connect(sigc::mem_fun(*this, &usb_boot::format));
    ext4.signal_clicked().connect(sigc::mem_fun(*this, &usb_boot::format));

    boutonQ.set_can_focus(false);
    boutonQ.signal_clicked().connect(sigc::ptr_fun(&Gtk::Main::quit));
    boutonQ.signal_clicked().connect(sigc::mem_fun(*this, &usb_boot::fin));

    ouvrirFichier.set_can_focus(true);
    ouvrirFichier.signal_clicked().connect(sigc::mem_fun(*this, &usb_boot::ouvrir_fichier));

    boutonOk.signal_clicked().connect(sigc::mem_fun(*this, &usb_boot::creation));

    boiteV.pack_start(listeDeroulante);
    boiteV.pack_start(fat32);
    boiteV.pack_start(ext4);
    boiteV.pack_start(ntfs);
    boiteH.pack_start(ouvrirFichier);
    boiteH.pack_start(boutonOk);
    boiteH.pack_start(boutonQ);
    boiteV.pack_start(boiteH);

    add(boiteV);

    //add(listeDeroulante);
    //listeDeroulante.show();
    show_all();


}
void usb_boot::afficher(){
    chemin = "";
    var = listeDeroulante.get_active_text();
    varNum = listeDeroulante.get_active_row_number();
    Gtk::MessageDialog *dialogue = new Gtk::MessageDialog("Afficher", true, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_OK);
    dialogue->set_title("Clé USB");
    std::stringstream ss;
    ss << "<span weight='bold'>" << "Clef USB actuellement sélectionnée" << "</span>";
    dialogue->set_message(ss.str().c_str(), true);
    ss.str("");
    ss << "<span foreground='blue' weight='bold'>" << varNum << " " << var << "</span>";
    dialogue->set_secondary_text(ss.str().c_str(), true);
    /*
    Gtk::MessageDialog dialogue(*this, listeDeroulante.get_active_text());
    dialogue.set_secondary_text("clef usb actuellement sélectionnée");
    */
    int result = dialogue->run();
    varGlobal = varNum + " " + var;
    std::cout << "Vous avez choisi la clé :\n" << varGlobal << std::endl;
    std::string::iterator ptr(varGlobal.end()-8);
    for(ptr; ptr != varGlobal.end(); ptr++){
        chemin += *ptr;
    }
    std::cout << "chemin = " << chemin << std::endl;
    if(Gtk::RESPONSE_OK){
        delete dialogue;
    }
    //std::cout << listeDeroulante.get_active_text() << std::endl;
    //std::cout << listeDeroulante.get_active_row_number() << std::endl;

}
void usb_boot::creation(){
    if(type == ""){
        type = "vfat";
    }
    //Gtk::MessageDialog dialogue(*this, listeDeroulante.get_active_text());
    std::string message("Type de formatage : " + type), type1, chemin1;
    Gtk::MessageDialog *dialogue = new Gtk::MessageDialog("Résumé", true, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_YES_NO);
    dialogue->set_title("Résumé");
    //dialogue->set_message("<span weight='bold'>message</span>",true);
    dialogue->set_border_width(10);
    std::stringstream ss;
    ss << "<span weight='bold'>" << listeDeroulante.get_active_text() << "</span>";
    dialogue->set_message(ss.str().c_str(),true);
    //dialogue->set_secondary_text("<b>listeDeroulante.get_active_text()</b>", true);
    //std::stringstream ss1;
    ss.str("");
    //ss.clear();
    ss << "<span weight='bold'>" << message << "</span>";
    dialogue->set_secondary_text(ss.str().c_str(),true);
    dialogue->set_default_response(Gtk::RESPONSE_YES);
    int result = dialogue->run();

    switch(result){

        case(Gtk::RESPONSE_NO):{
            std::cout << "RESPONSE_NO doit détruire la boîte de message" << std::endl;
            delete dialogue;
            break;
        }
        case(Gtk::RESPONSE_YES):{
            delete dialogue;
            std::cout << "Lance la création de la clé bootable" << std::endl;
            chemin1 = "chaine=" + chemin + "1"; //ex chemin1="chaine=/dev/sdf1"
            char c[chemin1.size() + 1];
            strcpy(c, chemin1.c_str());
            putenv(c);
            type1 = "type=" + type; //ex type1="type=vfat"
            char typeSys[type1.size() + 1];
            strcpy(typeSys, type1.c_str());
            putenv(typeSys);
            //formatage
            system("sudo umount $chaine");

            if(type == "vfat"){
                std::cout << "Formate la clé usb en fat32(vfat)" << std::endl;
                system("sudo mkfs.$type -n usb_boot $chaine");
            }
            if(type == "ntfs"){
                std::cout << "Formate la clé usb en " << type << std::endl;
                system("sudo mkfs.$type -f -L usb_boot $chaine");
            }
            if(type == "ext4"){
                std::cout << "Formate la clé usb en " << type << std::endl;
                system("sudo mkfs.$type -L usb_boot $chaine");
            }

            //copie des fichiers
            if(std::experimental::filesystem::exists("/mnt/usb")){
                std::cout << "Le dossier usb existe déjà.\nPas besoin de le créer" << std::endl;
            }
            else{
                std::cout << "Création du dossier usb" << std::endl;
                std::experimental::filesystem::create_directory("/mnt/usb");
            }
            if(std::experimental::filesystem::exists("/mnt/win")){
                std::cout << "Le dossier win existe déjà.\nPas besoin de le créer" << std::endl;
            }
            else{
                std::cout << "Création du dossier win" << std::endl;
                std::experimental::filesystem::create_directory("/mnt/win");
            }

            std::string filenamePath;
            system("echo chaine= $chaine");
            system("sudo mount $chaine /mnt/usb/");

            //usb_boot().close();
            break;
        }

        default:{
            std::cout << "Mauvais clic" << std::endl;
            break;
        }

    }
    //FIN
    fin();
}
void usb_boot::format()
{
    if(fat32.get_active()){
        std::cout << "fat32 sélectionné" << std::endl;
        type = "vfat";
    }
    if(ntfs.get_active()){
        std::cout << "ntfs sélectionné" << std::endl;
        type = "ntfs";
    }
    if(ext4.get_active()){
        std::cout << "ext4 sélectionné" << std::endl;
        type = "ext4";
    }


}
void usb_boot::ouvrir_fichier()
{
    Gtk::FileChooserDialog dialog("Choisir un fichier", Gtk::FILE_CHOOSER_ACTION_OPEN);
    dialog.set_transient_for(*this);

    //Add response buttons the the dialog:
    dialog.add_button("_Annuler", Gtk::RESPONSE_CANCEL);
    dialog.add_button("_Ouvrir", Gtk::RESPONSE_OK);

    //Add filters, so that only certain file types can be selected:

    auto filter_iso = Gtk::FileFilter::create();
    filter_iso->set_name("iso files");
    filter_iso->add_mime_type("application/x-cd-image");
    dialog.add_filter(filter_iso);

    auto filter_text = Gtk::FileFilter::create();
    filter_text->set_name("Text files");
    filter_text->add_mime_type("text/plain");
    dialog.add_filter(filter_text);

    auto filter_cpp = Gtk::FileFilter::create();
    filter_cpp->set_name("C/C++ files");
    filter_cpp->add_mime_type("text/x-c");
    filter_cpp->add_mime_type("text/x-c++");
    filter_cpp->add_mime_type("text/x-c-header");
    dialog.add_filter(filter_cpp);

    auto filter_any = Gtk::FileFilter::create();
    filter_any->set_name("Any files");
    filter_any->add_pattern("*");
    dialog.add_filter(filter_any);

    //Show the dialog and wait for a user response:
    int result = dialog.run();

    //Handle the response:
    switch(result)
    {
        case(Gtk::RESPONSE_OK):
        {
        std::cout << "Clic sur ouvrir" << std::endl;
        //Notice that this is a std::string, not a Glib::ustring.
        filename = dialog.get_filename();
        std::cout << "Fichier sélectionné : " <<  filename << std::endl;
        break;
        }
        case(Gtk::RESPONSE_CANCEL):
        {
        std::cout << "Clic sur annuler" << std::endl;
        break;
        }
        default:
        {
        std::cout << "Mauvais clic" << std::endl;
        break;
        }
    }
}
void usb_boot::fin(){
    std::cout << "Fin de l'opération" << std::endl;
    if(std::experimental::filesystem::exists("/mnt/usb")){
        system("sudo umount /mnt/usb");
        std::experimental::filesystem::remove("/mnt/usb");
    }
    if(std::experimental::filesystem::exists("/mnt/win")){
        system("sudo umount /mnt/win");
        std::experimental::filesystem::remove("/mnt/win");
    }
    if(std::experimental::filesystem::exists("usb.txt")){
        std::experimental::filesystem::remove("usb.txt");
    }

}
/*
usb_boot::type_signal_var usb_boot::signal_var(){
    return m_signal_var;
}
*/

et usb_boot.h

#ifndef USB_BOOT_H
#define USB_BOOT_H


#include <iostream>
#include <gtkmm/main.h>
#include <gtkmm-3.0/gtkmm/window.h>
#include <gtkmm-3.0/gtkmm/radiobutton.h>
#include <gtkmm-3.0/gtkmm/comboboxtext.h>
#include <gtkmm-3.0/gtkmm/messagedialog.h>
#include <gtkmm-3.0/gtkmm/button.h>
#include <gtkmm-3.0/gtkmm/box.h>
#include <gtkmm-3.0/gtkmm/stock.h>
#include <gtkmm-3.0/gtkmm/filechooserdialog.h>
#include <fstream>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <experimental/filesystem>


class usb_boot : public Gtk::Window{

    public:
        usb_boot();
        void afficher();
        void ouvrir_fichier();
        void format();
        void creation();
        void fin();
        std::string var, varGlobal, chemin, type, filename;
        int varNum;
        //typedef sigc::signal<void> type_signal_var;
        //type_signal_var signal_var();

    protected:
        //type_signal_var m_signal_var;

    private:
        Gtk::RadioButtonGroup groupe;
        Gtk::RadioButton fat32, ntfs, ext4;
        Gtk::Button boutonQ, boutonOk, ouvrirFichier;
        Gtk::HBox boiteH;
        Gtk::VBox boiteV;
        Gtk::ComboBoxText listeDeroulante;

};

#endif // USB_BOOT_H

Hors ligne

#6 Le 15/09/2020, à 20:29

NicoApi73

Re : Utiliser un programme en c++ sur un autre pc

Pour compiler sur le second PC, n'aurais tu pas installer les librairies gtkmm? Je pense que ça ne fonctionnait pas car il te manquait des librairies.

C'est toi qui a codé?

Hors ligne

#7 Le 15/09/2020, à 21:33

lanfust

Re : Utiliser un programme en c++ sur un autre pc

oui c'est moi; j'apprends le c++ .
d'où ma question première si je veux rendre mon programme portable sur un autre pc que faut il faire ?

Hors ligne

#8 Le 16/09/2020, à 07:13

NicoApi73

Re : Utiliser un programme en c++ sur un autre pc

lanfust a écrit :

d'où ma question première si je veux rendre mon programme portable sur un autre pc que faut il faire ?

A ta place, j'aurais fait un paquet (.deb), ce qui permet la gestion des dépendances. Sinon, il faut gérer toutes les dépendances à la main. Certes un .deb c'est beaucoup trop puissant pour ce que tu fais, mais comme tu apprends, c'est un bon exercice.
On voit clairement qu'il cherche à utiliser les bibliothèques graphiques qui n'étaient probablement pas installées.

Dans la structure de ton programme, tu mélanges la présentation des données (la vue), l'utilisation des données (le modèle) et ce qui permet de faire interagir les données et leur utilisation (le contrôleur). La conséquence est que pour faire évoluer ton code, tu seras probablement obliger de toucher à tout... Je te recommande donc de le structurer différemment.

Hors ligne