激情久久久_欧美视频区_成人av免费_不卡视频一二三区_欧美精品在欧美一区二区少妇_欧美一区二区三区的

服務器之家：專注于服務器技術及軟件下載分享
分類導航

PHP教程|ASP.NET教程|Java教程|ASP教程|編程技術|正則表達式|C/C++|IOS|C#|Swift|Android|VB|R語言|JavaScript|易語言|vb.net|

服務器之家 - 編程語言 - C/C++ - c++實現通用參數解析類示例

c++實現通用參數解析類示例

2021-01-16 13:23C++教程網 C/C++

使用命令行執行程序的時候在程序后可跟多個參數列表，而main函數的argc和argv分別存儲了相關的參數個數和參數內容，而循環輸入相關的時候就需要用戶自己來解析相關參數。以下代碼用c++的方式實現了相關解析的封裝，使用起來

main.cpp

復制代碼 代碼如下:


#include <iostream>
#include <getopt.h>
#include "parsingargs.h"
#include <string.h>

 


using namespace std;


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

    //string tmpPara = "-p \"4567\" --out 1.log "; //ok
    //string tmpPara = "xxxx -p \"4567\" --out 1.log ";//ok
    //string tmpPara = "-p \"4567\" --out 1.log 2.log"; //ok
    string tmpPara = "";
    for(int i=1;i <argc; i++)
    {
        cout << i << "=" << argv[i] <<"---"<< endl;
        if(strlen(argv[i]) == 0) //處理空字符串
        {
            cout << "find NULL" << endl;
            tmpPara += char(31);
        }
        else
        {
            tmpPara += argv[i];
        }
        tmpPara += " ";
    }
    std::map<std::string, std::vector<std::string> > result;
    ParsingArgs pa;
    pa.AddArgType('l',"getlist", ParsingArgs::NO_VALUE);
    pa.AddArgType('p',"getuser", ParsingArgs::MAYBE_VALUE);
    pa.AddArgType('o',"outFile", ParsingArgs::MUST_VALUE);
    bool bExit = false;
    do
    {
        result.clear();
        cout << "input is:" << tmpPara << "---size = " << tmpPara.size()<< endl;
        std::string errPos;
        int iRet = pa.Parse(tmpPara,result, errPos);
        if(0>iRet)
        {
            cout << "參數錯誤" << iRet << errPos << endl;
        }
        else
        {
            map<std::string, std::vector<std::string> >::iterator it = result.begin();
            for(; it != result.end(); ++it)
            {
                cout << "key=" << it->first<<endl;
                for(int i=0; i<it->second.size(); ++i)
                {
                    cout << "   value =" << it->second[i] << "------" << endl;
                }
            }
        }
        string str;
        cout << ">>> ";
        getline(cin, tmpPara);
        if(0 == tmpPara.compare("exit"))
        {
            bExit = true;
        }

    }while(!bExit);
    return 0;
}

 

parsingargs.h

 

復制代碼 代碼如下:


#ifndef PARSINGARGS_H
#define PARSINGARGS_H
/* purpose @ 解析輸入的參數，需先通過AddArgType將必須參數和可允許的參數key加入到判定列表中
 *          通過Parse中的result將結果返回，其中結果的key為合法的key，vecotr為參數列表
 *          參數列表支持去掉參數前后的引號和\對引號和\的轉義
 *
 *          特殊合法字段：
 *          格式               實際存儲值
 *          \\value\"            \value"
 *          "\\\value\""         \value"
 *
 *          注意事項：
 *              1、輸入參數列表中參數分隔以空格區分
 *              2、- 后跟單字符關鍵字，--后跟長字符串關鍵字
 *              3、關鍵字不能重復出現，長短關鍵字不能同時出現在參數列表，否則會Parse函數會提示參數錯誤
 *
 *          用法：
 *              ParsingArgs pa;
 *              pa.AddArgType('l',"getlist", ParsingArgs::NO_VALUE); //NO_VALUE關鍵字后不能有參數
 *              pa.AddArgType('p',"getuser", ParsingArgs::MAYBE_VALUE); //MAYBE_VALUE 關鍵字后可能有關鍵字
 *              pa.AddArgType('o',"outFile", ParsingArgs::MUST_VALUE); // MUST_VALUE 關鍵字后必須有參數
 *              std::map<std::string, std::vector<std::string> > result;
 *              int iRet = pa.Parse(tmpPara,result); //result以輸入關鍵字為key存儲相關的值序列
 *
 * date    @ 2014.02.19
 * author  @ haibin.wang
 *
 */

 

#include <map>
#include <vector>
#include <string>

class ParsingArgs
{
public:
    ParsingArgs();
    ~ParsingArgs();
    enum KeyFlag{ INVALID_KEY=-1, NO_VALUE, MAYBE_VALUE, MUST_VALUE};
    /* pur @ 添加解釋參數，一個參數可以是長參數，也可以是縮寫的段參數，短參數只能為單字符，longName和shortName至少要有一個
     * para @ shortName 短參數名,0為不要短參數
     * para @ longName 長參數名 ，NULL為不要長參數
     * para @ flag 是否需要參數，0不需要，1必須要，2可要可不要
     * return @ true 添加成功，false添加失敗
    */
    bool AddArgType(const char shortName, const char * longName = NULL, KeyFlag flag=NO_VALUE);

    /* pur @ 根據參數類型解釋傳入的字符串
     * para @ paras 需要解釋的字符串
     * para @ result 返回解析后的結果
     * para @ errPos 當錯誤的時候返回出錯的大概位置
     * return @ 0 解釋成功，負數 解釋失敗
     *          -1 未知參數錯誤
                -2 不能有參數的選項有參數錯誤
     *          -3 必有參數選項后沒有跟參數
     *          -4 關鍵字沒有加入到AddArgType中
     *          -5 關鍵字重復
    */
    int Parse(const std::string & paras, std::map<std::string, std::vector<std::string> > & result, std::string &errPos);

private:
    /* pur @ 判定傳入的參數是否是已經添加的參數類型,如果是則去掉-或--,并返回
     * para @ key 要判定的參數
     * return @ -1 不是合法參數類型 否則返回Option中的flag
    */
    KeyFlag GetKeyFlag(std::string &key);

    /* pur @ 刪除關鍵字前的-或--
    */
    void RemoveKeyFlag(std::string & paras);

    /* pur @ 從Paras中獲取一個單詞，自動過濾掉單詞前后引號，并實現\對空格和引號的轉義
     * para @ Paras 返回第一個單詞后的所有內容
     * para @ word 返回第一單詞
     * return @ 成功返回true，false失敗
     */
    bool GetWord(std::string & Paras, std::string & word);

    /* pur @ 檢查關鍵字是否重復
     * para @ key 被檢查的關鍵字
     * para @  result已存儲的關鍵字序列
     * return @ true 是重復的，false不重復
    */
    bool IsDuplicateKey(const std::string &key, const std::map<std::string, std::vector<std::string> > & result);

    struct Option
    {
        std::string m_longName;
        char m_shortName;
        KeyFlag m_flag;
    };

    std::vector<Option> m_args; //參數信息列表
};

#endif

 

parsingargs.cpp

 

復制代碼 代碼如下:


#include "parsingargs.h"
#include <list>

 

ParsingArgs::ParsingArgs()
{
}

ParsingArgs::~ParsingArgs()
{
}

bool ParsingArgs::AddArgType(char shortName, const char * longName, KeyFlag flag)
{
    if(NULL == longName && 0 == shortName)
    {
        return false;
    }
    Option tmp;
    tmp.m_longName = longName;
    tmp.m_shortName = shortName;
    tmp.m_flag = flag;
    m_args.push_back(tmp);
    return true;
}

ParsingArgs::KeyFlag ParsingArgs::GetKeyFlag(std::string &key) //返回flag，
{
    for(int i=0; i<m_args.size(); ++i)
    {
        std::string shortName = "-";
        std::string longName = "--";
        shortName += m_args[i].m_shortName;
        longName += m_args[i].m_longName;
        if( 0 == key.compare(shortName) ||
                (0==key.compare(longName))
            )
        {
            RemoveKeyFlag(key);
            return m_args[i].m_flag;
        }
    }
    return INVALID_KEY;
}

void ParsingArgs::RemoveKeyFlag(std::string & word)
{
    if(word.size()>=2)
    {
        if(word[1] == '-')
        {
            word.erase(1,1);
        }
        if(word[0] == '-')
        {
            word.erase(0,1);
        }
    }
}
/* pur @ 從Paras中獲取一個單詞，自動過濾掉單詞前后引號，并實現\對空格和引號的轉義
 * para @ Paras 返回第一個單詞后的所有內容
 * para @ word 返回第一單詞
 * return @ 成功返回true，false失敗
*/
bool ParsingArgs::GetWord(std::string & Paras, std::string & word)
{
    size_t iNotSpacePos = Paras.find_first_not_of(' ',0);//查找第一個非空格字符位置
    if(iNotSpacePos == std::string::npos)
    {
        Paras.clear();
        word.clear();
        return true;
    }
    int length = Paras.size();
    std::list<char> specialChar;
    int islashPos = -1;
    for(int i=iNotSpacePos; i<length; i++)
    {
        char cur=Paras[i];
        bool bOk = false;
        switch(cur)
        {
            case ' ':
                if(specialChar.empty())
                {
                    if(i!=(length-1))
                    {
                        Paras = std::string(Paras, i+1, length-i-1);
                    }
                    else
                    {//最后一個是空格
                        Paras.clear();
                    }
                    bOk = true;
                }
                else
                {                   
                    if(specialChar.back() == '\\')
                    {
                        specialChar.pop_back();
                    }
                    word.append(1,cur);
                }
                break;
            case '"':
                if(specialChar.empty())
                {
                    specialChar.push_back(cur);
                }
                else if(specialChar.back() == cur)
                { //找到匹配的括號
                    specialChar.pop_back();
                }
                else if(specialChar.back() == '\\')
                {
                    word.append(1,cur);
                    specialChar.pop_back();
                }
                else
                {
                    word.clear();
                    return false;
                }
                break;
            case '\\':
                if(specialChar.empty())
                {
                    specialChar.push_back(cur);
                    islashPos = i;
                }
                else if(specialChar.back() == '"')
                {
                    if(i<(length-1))
                    {
                        if('"'==Paras[i+1] || '\\'==Paras[i+1])
                        {
                            specialChar.push_back(cur);
                        }
                        else
                        {
                            word.append(1,cur);
                        }
                    }
                    else
                    {
                        word.clear();
                        return false;
                    }
                }
                else if('\\' == specialChar.back())
                {
                     word.append(1,cur);
                     specialChar.pop_back();
                }
                else
                {
                    word.clear();
                    return false;
                }
                break;
            default:
                word.append(1,Paras[i]);
                if(i==(length-1))
                {
                    bOk = true;
                    Paras.clear();
                }
                break;
        }
        if(bOk)
        {
            return true;
        }
    }//for end
    if(specialChar.empty())
    {
        Paras.clear();
        return true;
    }
    else
    {
        return false;
    }
}

bool ParsingArgs::IsDuplicateKey(const std::string &key, const std::map<std::string, std::vector<std::string> > & result)
{
    if(result.find(key) != result.end())
    {
        return true; //關鍵字重復
    }

    for(int i=0; i<m_args.size(); ++i)
    {
        if( (key.compare(m_args[i].m_longName) == 0 && result.find(std::string(1, m_args[i].m_shortName)) != result.end())
                || (key.compare(std::string(1, m_args[i].m_shortName)) == 0 && result.find(m_args[i].m_longName) != result.end())
          )
        {
            return true;
        }
    }
    return false;
}

int ParsingArgs::Parse(const std::string & Paras, std::map<std::string, std::vector<std::string> > & result, std::string &errPos)
{
    std::string tmpString = Paras;
    KeyFlag keyFlag = INVALID_KEY; //參數標識
    std::string sKey = ""; //key關鍵字
    bool bFindValue = false; //是否已經有value
    while(!tmpString.empty())
    {
        std::string word = "";

        bool bRet = GetWord(tmpString, word);

        if(bRet == false)
        {
            errPos = tmpString;
            return -4;//參數解析錯誤
        }
        else
        {
            KeyFlag tmpFlag = GetKeyFlag(word);
            if(IsDuplicateKey(word, result))
            {
                errPos = tmpString;
                return -5;
            }
            if(tmpFlag != INVALID_KEY)
            {
                if(tmpFlag == MUST_VALUE && keyFlag == MUST_VALUE && !bFindValue)
                {
                    errPos = tmpString;
                    return -3;
                }
                keyFlag = tmpFlag;
                std::vector<std::string> tmp;
                result[word] = tmp;
                sKey = word;
                bFindValue = false;
            }
            else
            {
                switch(keyFlag)
                {
                    case MAYBE_VALUE:
                    case MUST_VALUE:
                        {
                            std::map<std::string, std::vector<std::string> >::iterator it = result.find(sKey);
                            if(it != result.end())
                            {
                                it->second.push_back(word);
                                bFindValue = true;
                            }
                            else
                            {
                                errPos = tmpString;
                                return -1;// 沒有發現相關的key
                            }
                        }
                        break;
                    case NO_VALUE:
                        errPos = tmpString;
                        return -2; //不能有參數的選項后有參數
                    default:
                        errPos = tmpString;
                        return -1;//參數錯誤
                }//switch end
            }
        }
    }//while end
    return 0;
}

 

延伸 · 閱讀

精彩推薦
  • C/C++C/C++經典實例之模擬計算器示例代碼

    C/C++經典實例之模擬計算器示例代碼

    最近在看到的一個需求，本以為比較簡單，但花了不少時間，所以下面這篇文章主要給大家介紹了關于C/C++經典實例之模擬計算器的相關資料，文中通過示...

    jia150610152021-06-07
  • C/C++C語言中炫酷的文件操作實例詳解

    C語言中炫酷的文件操作實例詳解

    內存中的數據都是暫時的,當程序結束時,它們都將丟失,為了永久性的保存大量的數據,C語言提供了對文件的操作,這篇文章主要給大家介紹了關于C語言中文件...

    針眼_6702022-01-24
  • C/C++學習C++編程的必備軟件

    學習C++編程的必備軟件

    本文給大家分享的是作者在學習使用C++進行編程的時候所用到的一些常用的軟件，這里推薦給大家...

    謝恩銘10102021-05-08
  • C/C++詳解c語言中的 strcpy和strncpy字符串函數使用

    詳解c語言中的 strcpy和strncpy字符串函數使用

    strcpy 和strcnpy函數是字符串復制函數。接下來通過本文給大家介紹c語言中的strcpy和strncpy字符串函數使用，感興趣的朋友跟隨小編要求看看吧...

    spring-go5642021-07-02
  • C/C++C語言實現電腦關機程序

    C語言實現電腦關機程序

    這篇文章主要為大家詳細介紹了C語言實現電腦關機程序，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下...

    xiaocaidayong8482021-08-20
  • C/C++深入理解goto語句的替代實現方式分析

    深入理解goto語句的替代實現方式分析

    本篇文章是對goto語句的替代實現方式進行了詳細的分析介紹，需要的朋友參考下...

    C語言教程網7342020-12-03
  • C/C++C++之重載 重定義與重寫用法詳解

    C++之重載 重定義與重寫用法詳解

    這篇文章主要介紹了C++之重載 重定義與重寫用法詳解,本篇文章通過簡要的案例,講解了該項技術的了解與使用,以下就是詳細內容,需要的朋友可以參考下...

    青山的青6062022-01-04
  • C/C++c++ 單線程實現同時監聽多個端口

    c++ 單線程實現同時監聽多個端口

    這篇文章主要介紹了c++ 單線程實現同時監聽多個端口的方法，幫助大家更好的理解和學習使用c++，感興趣的朋友可以了解下...

    源之緣11542021-10-27
主站蜘蛛池模板： 天天舔天天插 | 中国美女一级黄色大片 | 一区二区三区播放 | 久久久久久99 | 国产一国产一级毛片视频 | 91av在线免费视频 | 久久久精品精品 | 日韩在线观看高清 | 欧美一级黄色影院 | 在线看91 | 成人一级视频 | 欧美亚洲综合在线 | 在线男人天堂 | 日本aⅴ在线 | 嫩草影院在线观看网站成人 | 91看片在线观看视频 | 久久久久久久久久91 | 日日草夜夜草 | 一本一本久久a久久精品综合小说 | 毛片免费看网站 | 91高清观看 | 久久久国产视频 | 国产精品视频2021 | 国产精品亚洲综合一区二区三区 | 午夜影视一区二区 | 成人免费网站在线观看 | 日本精品一区二区 | 羞羞的视频免费 | 九九热在线精品视频 | av免费在线观看国产 | 欧美精品一区二区三区久久久 | 久久国产精品99久久人人澡 | 蜜桃成品人免费视频 | 99精品视频一区二区三区 | omofun 动漫在线观看 | 国产精品成人一区二区三区电影毛片 | 亚洲一区二区三区在线看 | 一级做a在线观看 | 在线视频a| 久久精品欧美一区 | 一级黄色影院 |