Intro :
[utiliser la classe DataParameters]
On peut passer à exécutable des paramètres comme suit : mon_exécutable.exe -param1 arg1 arg2 -param2 arg3
Cette classe va vous permettre de les récupérer vos arguments plus facilement.
Préréquis :
– Savoir lire du C++
– Savoir écrire un programme rudimentaire en C++
Explications :
Voici le fichier d’en-tête ParametersManager.h :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
#ifndef PARAMETERS_MANAGER_H #define PARAMETERS_MANAGER_H /** * \brief Une classe pour gérer les paramètres des arguments d'entrée de * ligne de commande du programme. */ class Parameter { public: Parameter(std::string sName); virtual ~Parameter(); // Met un argument du paramètre void pushArgument(const std::string& sArgument); // Récupère le nom du paramètre const std::string& getName() const; // Récupère un argument const char* getArgument(unsigned int iArgumentNumber) const; // Retourne le nombre d'argument int getArgumentCount() const; private: std::string m_sName; std::vector<std::string> m_vArguments; }; class CommandLineManager : public Singleton<CommandLineManager> { public: CommandLineManager(int argc, char* argv[]); ~CommandLineManager(); // Est-ce que la ligne de commande a ce paramètre bool hasParameter(const std::string& sParameter); // Le nombre de paramètre int getParameterCount(); // Récupère le paramètre Parameter* getParameter(const std::string& sParameter); private: // Evalue la ligne de commande void parseCommandLineArguments(int iArgumentCount, char* paArguments[]); private: std::map<std::string, Parameter*> m_vParameters; }; #endif |
Voici le fichier .cpp :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 |
// Format : -PARAM ARG1 ARG2... Parameter::Parameter(std::string sName) : m_sName(sName) { } Parameter::~Parameter() { } // On ajoute les arg1, arg2 à la suite des un et des autres void Parameter::pushArgument(std::string sArgument) { m_vArguments.push_back(sArgument); } const char* Parameter::getArgument(unsigned int iArgumentNumber) const { if (iArgumentNumber < m_vArguments.size()) return m_vArguments[iArgumentNumber].c_str(); else return "Unknown"; } int Parameter::getArgumentCount() const { return m_vArguments.size(); } /********************************** Déclaration de la classe CommandLineManager **********************************/ CommandLineManager::CommandLineManager(int argc, char* argv[]) { parseCommandLineArguments(argc, argv); } CommandLineManager::~CommandLineManager() { // Libère les objets paramètre de la mémoire. std::map<std::string, Parameter*>::iterator it; for (it = m_vParameters.begin(); it != m_vParameters.end(); ++it) { Parameter* pParam = (*it).second; SAFE_DELETE(pParam); } } void CommandLineManager::parseCommandLineArguments(int iArgumentCount, char* paArguments[]) { Parameter* pCurrentParameter = nullptr; // Exemple de ligne de commande : game.exe -fullscreen -res 800 600 -opengl for (int i = 0; i < iArgumentCount; ++i) { std::string sCurrentArgumentName(paArguments[i]); // Si on a un nouvel argument qui commence par un '-'. if (sCurrentArgumentName[0] == '-') { // On enlève l'indicateur de paramètre (premier caractère). sCurrentArgumentName.erase(0, 1); // On créé un nouveau objet paramètre avec son nom. pCurrentParameter = new Parameter(sCurrentArgumentName); // On l'ajoute dans la liste des arguments. m_vParameters[sCurrentArgumentName] = pCurrentParameter; } else if (pCurrentParameter)// C'est peut-être un argument, (paramètre qui ne commence pas par '-'). { pCurrentParameter->pushArgument(sCurrentArgumentName); } } } bool CommandLineManager::hasParameter(const std::string& sParameter) { return m_vParameters.count(sParameter) > 0; } int CommandLineManager::getParameterCount() { return m_vParameters.size(); } Parameter* CommandLineManager::getParameter(const std::string& sParameter) { if (m_vParameters.count(sParameter) > 0) { return m_vParameters[sParameter]; } else { return nullptr; } } |
Utilisation :
On utilise ce bout de code dans la fonction main (int argc, char** argv) :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
CommandLineManager* pCommandLineManager = new CommandLineManager(argc, argv); // Bloc d'analyse des arguments de ligne de commande, etc... unsigned int iWindowWidth = SYSTEM_MINIMUM_WINDOW_WIDTH; unsigned int iWindowHeight = SYSTEM_MINIMUM_WINDOW_HEIGHT; bool bFullScreen = false; // Si on a au moins un paramètre. if (pCommandLineManager->getParameterCount() > 0) { // Paramètre de résolution de la fenêtre if (pCommandLineManager->hasParameter("res")) { Parameter* pWindowResParameter = pCommandLineManager->getParameter("res"); if (pWindowResParameter->getArgumentCount() > 1) { // Acquisition des paramètres de résolution de la fenêtre std::string sResolutionWidth = pWindowResParameter->getArgument(0); std::string sResolutionHeight = pWindowResParameter->getArgument(1); iWindowWidth = atoi(sResolutionWidth.c_str()); iWindowHeight = atoi(sResolutionHeight.c_str()); } } if (pCommandLineManager->hasParameter("fullscreen")) bFullScreen = true; } |
Résumé :
Nous avons présenté une méthode pour analyser vos arguments en ligne de commande.