命令参数的解析

刚写了一个命令参数解析的程序，使用getopt。

主要代码如下：

复制

#include <stdio.h>

#include <string>

#include <map>

#include <stdlib.h>



#include "operation.h"



using namespace std;

std::map<char,operation_context_t> operation_contexts;



#define no_argument 0

#define required_argument 1

#define optional_argument 2





struct option *options = NULL;



static int operation_p(char *arg)

{

    TestItemManager &tm = (TestItemManager&)TestItemManager::GetInstance();

    tm.TestItemPrint();

}



static int operation_test(char *arg)

{

    TestItemManager &tm = (TestItemManager&)TestItemManager::GetInstance();

    tm.TestSpecific(arg);

}



static int operation_a(char *arg)

{

    TestItemManager &tm = (TestItemManager&)TestItemManager::GetInstance();

    tm.TestAll();

}







void operation_contexts_init()

{

        int i = 0;

        char opt;

        opt = 'p';

        operation_contexts.insert(pair<char,operation_context_t>(opt,{.m_option={.name = "p",.has_arg=no_argument,.flag=NULL,.val=opt},.operation=operation_p}));

        opt = 't';

        operation_contexts.insert(pair<char,operation_context_t>(opt,{.m_option={.name = "test",.has_arg=required_argument,.flag=NULL,.val=opt},.operation=operation_test}));

        opt = 'n';

        operation_contexts.insert(pair<char,operation_context_t>(opt,{.m_option={.name = NULL,.has_arg= 0,.flag=NULL,.val=opt},.operation=operation_null}));



        options = (struct option *)malloc(sizeof(struct option) * operation_contexts.size());

        if(options != NULL) {

                map<char,operation_context_t>::reverse_iterator iter;

                for(iter = operation_contexts.rbegin(); iter != operation_contexts.rend(); iter++) {



                        options[i].name = ((operation_context_t)(iter->second)).m_option.name;

                        options[i].has_arg = ((operation_context_t)(iter->second)).m_option.has_arg;

                        options[i].flag = ((operation_context_t)(iter->second)).m_option.flag;

                        options[i].val = ((operation_context_t)(iter->second)).m_option.val;

                        i ++;

                }

        }

}



int run_operation(char opt,char *arg)

{

        map<char,operation_context_t>::iterator iter;  

  

    iter = operation_contexts.find(opt);  

  

    if(iter != operation_contexts.end())  {

                return operation_contexts[opt].operation(arg);

    }

}

使用用例：

复制

#include <string>

#include <stdio.h>

#include <unistd.h>

#include <getopt.h>

#include "operation.h"





extern struct option *options;



int main(int argc, char *argv[])

{

    int opt;

    int digit_optind = 0;

    int option_index = 0;

    std::string str = "a::b:c:d";



        operation_contexts_init();

        

        if(options != NULL) {

                while((opt = getopt_long_only(argc,argv,str.c_str(),options,&option_index))!= -1) {  

                run_operation(opt,optarg);

            }  

        }

}

@yyy71cj @dirtwillfly

测试项：
头文件

复制

#ifndef __TEST_ITEM_H__

#define __TEST_ITEM_H__



#include <string>

#include <map>





///////////////////////////////////////// test item /////////////////////////////////////////

class TestItem

{

public:

        virtual int Test() = 0;

protected:

        std::string m_itemName;

};





///////////////////////////// ublox ///////////////////////////////



class TestUblox : public TestItem

{

public:

        TestUblox(std::string itemName);

        int Test();

};





///////////////////////////// emmc ///////////////////////////////



class TestEmmc : public TestItem

{

public:

        TestEmmc(std::string itemName);

        int Test();

};



///////////////////////////// can ///////////////////////////////



class TestCan : public TestItem

{

public:

        TestCan(std::string itemName);

        int Test();

};





////////////////////////////////////////// item manager ///////////////////////////////////////



class TestItemManager {

public:

        static TestItemManager& GetInstance();

        TestItemManager();



        int TestAll();

        int TestSpecific(std::string itemName);

        int TestItemPrint();

private:

        std::map<std::string,TestItem*> m_testItems;

};



#endif

.cpp文件：

复制

#include <iostream>

#include "test_item.h"





using namespace std;



///////////////////////////////////////// TestUblox ///////////////////////////////////////////////

TestUblox::TestUblox(string itemName) 

{

        m_itemName = itemName;

}



int TestUblox::Test()

{

        cout << "== ublox test" << endl;

}



///////////////////////////////////////// TestEmmc ////////////////////////////////////////////////

TestEmmc::TestEmmc(string itemName) 

{

        m_itemName = itemName;

}



int TestEmmc::Test()

{

        cout << "== emmc test" << endl;

}





///////////////////////////////////////// TestCan ////////////////////////////////////////////////

TestCan::TestCan(string itemName) 

{

        m_itemName = itemName;

}



int TestCan::Test()

{

        cout << "== can test" << endl;

}





////////////////////////////////////////// item manager ///////////////////////////////////////



TestItemManager::TestItemManager()

{

        string itemName;

        

        itemName = "ublox";

        m_testItems.insert(pair<string,TestItem*>(itemName,new TestUblox(itemName)));

        

        itemName = "emmc";

        m_testItems.insert(pair<string,TestItem*>(itemName,new TestEmmc(itemName)));

        

        itemName = "can";

        m_testItems.insert(pair<string,TestItem*>(itemName,new TestCan(itemName)));

        

}





TestItemManager& TestItemManager::GetInstance()

{

        static TestItemManager t_inst;

        return t_inst;

}





int TestItemManager::TestAll()

{

        map<string,TestItem*>::iterator iter;

        for(iter = m_testItems.begin(); iter != m_testItems.end(); iter++) {

                ((TestItem*)(iter->second))->Test();

        }

}



int TestItemManager::TestSpecific(string itemName)

{

        map<string,TestItem*>::iterator iter;  

  

    iter = m_testItems.find(itemName);  

  

    if(iter != m_testItems.end())  {

                return m_testItems[itemName]->Test();

    }

}



int TestItemManager::TestItemPrint()

{

        map<string,TestItem*>::iterator iter;

        for(iter = m_testItems.begin(); iter != m_testItems.end(); iter++) {

                cout << iter->first << " ";

        }



        cout << endl;

}