一个C++开发的命令行参数解析的小工具

最新推荐文章于 2024-05-17 00:32:12 发布
最新推荐文章于 2024-05-17 00:32:12 发布
阅读量132 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28646705/article/details/132912390
版权 
#include "version.h"
 
#include "cmdline/cmdline.h"
#include "util/single.hpp"
#include "log/log.h"
 
#include <vector>
#include <list>
#include <set>
#include <queue>
#include <stack>
#include <deque>
#include <forward_list>
#include <unordered_set>
 
using namespace lmc;
 
int main(int argc, char *argv[])
{
    CmdLine *cmd = TypeSingle<CmdLine>::getInstance();
    cmd->add<std::vector<short>>("-s", "--short", "get short", {}, {33, 55});
    cmd->add<std::vector<unsigned short>>("-us", "--us", "get unsigned short");
    cmd->add<std::vector<int>>("-i", "--int", "get int");
    cmd->add<std::vector<unsigned int>>("-ui", "--ui", "get unsigned int",
                                        {"-s", "-us", "-i"});
    cmd->add<std::vector<float>>("-f", "--float", "get float", {}, {23, 100});
    cmd->add<std::vector<double>>("-d", "--double", "get double");
    cmd->add<std::vector<long>>("-l", "--long", "get long");
    cmd->add<std::vector<unsigned long>>("-ul", "--ul", "get unsigned long");
    cmd->add<std::vector<std::string>>("-string", "--string", "get string", 
                                       {}, {"aaa", "vvv", "bbb", "rrr", "ttt"});
    cmd->add<std::list<std::string>>("-ls", "--lstring", "get list string", 
                                     {}, {"aaa", "vvv", "bbb", "rrr", "ttt"});
    cmd->add<std::set<std::string>>("-ss", "--sstring", "get set string", 
                                    {}, {"aaa", "vvv", "bbb", "rrr", "ttt"});
    cmd->add<std::set<int>>("-si", "--sint", "get set int", 
                           {"-ss", "-us"}, {44, 99});
    cmd->add<std::deque<std::string>>("-ds", "--dstring", "get deque string", 
                                      {}, {"aaa", "vvv", "bbb", "rrr", "ttt"});
    cmd->add<std::deque<int>>("-di", "--dint", "get deque int", {}, {44, 99});
    cmd->add<std::queue<std::string>>("-dsss", "--queuestring", 
                                      "get queue string", 
                                      {}, std::queue<std::string>({"aaa", 
                                      "vvv", "bbb", "rrr", "ttt"}));
    cmd->add<std::queue<int>>("-diss", "--queueint", "get queue int", 
                              {}, std::queue<int>({44, 99}));
    cmd->add<std::stack<std::string>>("-dsa", "--stackstring", 
                                      "get stack string", 
                                      {}, std::stack<std::string>({"aaa", 
                                      "vvv", "bbb", "rrr", "ttt"}));
    cmd->add<std::stack<int>>("-dix", "--stackint", "get stack int", 
                              {}, std::stack<int>({44, 99}));
    cmd->add<std::forward_list<std::string>>("-flstring", 
                                             "--forwardliststring", 
                                             "get forward_list string", 
                                             {}, {"aaa", "vvv", "bbb", 
                                             "rrr", "ttt"});
    cmd->add<std::forward_list<int>>("-flint", "--forwardlistint", 
                                     "get forward_list int", {}, {44, 99});
    cmd->add<std::multiset<std::string>>("-mmstr", "--multisetstring", 
                                         "get multiset string", 
                                         {}, {"aaa", "vvv", "bbb", 
                                         "rrr", "ttt"});
    cmd->add<std::multiset<int>>("-mmint", "--multisetint", "get multiset int", 
                                 {}, {44, 99});
    cmd->add<std::unordered_set<std::string>>("-unstr", "--unorderedsetstring", 
                                              "get unordered_set string", 
                                              {}, {"aaa", "vvv", "bbb", 
                                              "rrr", "ttt"});
    cmd->add<std::unordered_set<int>>("-unint", "--unorderdsetint", 
                                      "get unordered_set int", {}, {44, 99});
    cmd->add<std::unordered_multiset<std::string>>("-unmstr", 
                                                   "--unorderedmsetstring", 
                                                   "get unordered_multiset string", 
                                                   {}, 
                                                   {"aaa", "vvv", "bbb", "rrr"});
    // add specified type of variable.
    // 1st argument is short name
    // 2nd argument is long name
    // 3rd argument is description
    // 4th argument is depends option
    // 5th argument is paramter ranage
    cmd->add<std::unordered_multiset<int>>("-unmint", "--unorderdmsetint", 
                                           "get unordered_multiset int", 
                                           {"-dix"}, {44, 99});
    // add specified type of variable.
    // 1st argument is long name
    // 2nd argument is short name (no short name if '\0' specified)
    // 3rd argument is description
    // 4th argument is depends option
    cmd->add("-n", "--none", "get none", {"-s", "-us", "-i"});
    // add specified type of variable.
    // 1st argument is long name
    // 2nd argument is short name (no short name if '\0' specified)
    // 3rd argument is description
    // 4th argument is depends option
    // 5th argument is paramter ranage
    cmd->add<std::string>("-sns", "--singlestring", "get single string", 
                         {"-s", "-us", "-i"}, 
                         {"aaa", "vvv", "bbb", "rrr", "ttt"});
    cmd->add<int>("-sni1", "--singleint1", "get single int1", 
                 {"-s", "-us", "-i"}, {12, 33});
    cmd->add<int>("-sni2", "--singleint2", "get single int2", 
                 {"-s", "-us", "-i"}, {12, 33});
    cmd->add("-v", "--version", "get version");
  
    cmd->parse(false, argc, argv);
 
    Logger::setLevel(LogLevel::all);
 
    bool ret = cmd->get("--none");
    if (ret)
    {
        LOGGER << "--none enable";
    }
 
    ret = cmd->get("--version");
    if (ret)
    {
        LOGGER << "version: " << PROJECT_VERSION;
    }
 
    std::string singleStr;
    ret = cmd->get("--singlestring", singleStr);
    if (ret)
    {
        LOGGER << singleStr;
    }
 
    int singleInt1;
    ret = cmd->get("--singleint1", singleInt1);
    if (ret)
    {
        LOGGER << singleInt1;
    }
 
    int singleInt2;
    ret = cmd->get("--singleint2", singleInt2);
    if (ret)
    {
        LOGGER << singleInt2;
    }
 
    std::vector<short> sVector;
    ret = cmd->get("--short", sVector);
    if (ret)
    {
        for (auto &v : sVector)
        {
            LOGGER << v;
        }
    }
 
    std::vector<unsigned short> usVector;
    ret = cmd->get("--us", usVector);
    if (ret)
    {
        for (auto &v : usVector)
        {
            LOGGER << v;
        }
    }
 
    std::vector<unsigned int> uiVector;
    ret = cmd->get("--ui", uiVector);
    if (ret)
    {
        for (auto &v : uiVector)
        {
            LOGGER << v;
        }
    }
 
    std::vector<int> iVector;
    ret = cmd->get("--int", iVector);
    if (ret)
    {
        for (auto &v : iVector)
        {
            LOGGER << v;
        }
    }
 
    std::vector<float> fVector;
    ret = cmd->get("--float", fVector);
    if (ret)
    {
        for (auto &v : fVector)
        {
            LOGGER << v;
        }
    }
 
    std::vector<double> dVector;
    ret = cmd->get("--double", dVector);
    if (ret)
    {
        for (auto &v : dVector)
        {
            LOGGER << v;
        }
    }
 
    std::vector<long> lVector;
    ret = cmd->get("--long", lVector);
    if (ret)
    {
        for (auto &v : lVector)
        {
            LOGGER << v;
        }
    }
 
    std::vector<unsigned long> ulVector;
    ret = cmd->get("--ul", ulVector);
    if (ret)
    {
        for (auto &v : ulVector)
        {
            LOGGER << v;
        }
    }
  
    std::vector<std::string> strVector;
    ret = cmd->get("--string", strVector);
    if (ret)
    {
        for (auto &v : strVector)
        {
            LOGGER << v;
        }
    }
 
    std::list<std::string> strList;
    ret = cmd->get("--lstring", strList);
    if (ret)
    {
        for (auto &v : strList)
        {
            LOGGER << v;
        }
    }
 
    std::set<std::string> strSet;
    ret = cmd->get("--sstring", strSet);
    if (ret)
    {
        for (auto &v : strSet)
        {
            LOGGER << v;
        }
    }
 
    std::set<int> intSet;
    ret = cmd->get("--sint", intSet);
    if (ret)
    {
        for (auto &v : intSet)
        {
            LOGGER << v;
        }
    }
 
    std::deque<std::string> strDeque;
    ret = cmd->get("--dstring", strDeque);
    if (ret)
    {
        for (auto &v : strDeque)
        {
            LOGGER << v;
        }
    }
 
    std::deque<int> intDeque;
    ret = cmd->get("--dint", intDeque);
    if (ret)
    {
        for (auto &v : intDeque)
        {
            LOGGER << v;
        }
    }
 
    std::queue<std::string> strQueue;
    ret = cmd->get("--queuestring", strQueue);
    if (ret)
    {
        int size = strQueue.size();
        for (int i = 0; i < size; i++)
        {
            auto s = strQueue.front();
            LOGGER << s;
            strQueue.pop();
        }
    }
 
    std::queue<int> intQueue;
    ret = cmd->get("--queueint", intQueue);
    if (ret)
    {
        int size = intQueue.size();
        for (int i = 0; i < size; i++)
        {
            auto s = intQueue.front();
            LOGGER << s;
            intQueue.pop();
        }
    }
 
    std::stack<std::string> strStack;
    ret = cmd->get("--stackstring", strStack);
    if (ret)
    {
        int size = strStack.size();
        for (int i = 0; i < size; i++)
        {
            auto s = strStack.top();
            LOGGER << s;
            strStack.pop();
        }
    }
 
    std::stack<int> intStack;
    ret = cmd->get("--stackint", intStack);
    if (ret)
    {
        int size = intStack.size();
        for (int i = 0; i < size; i++)
        {
            auto s = intStack.top();
            LOGGER << s;
            intStack.pop();
        }
    }
 
    std::forward_list<std::string> strForwardList;
    ret = cmd->get("--forwardliststring", strForwardList);
    if (ret)
    {
        for (auto &v : strForwardList)
        {
            LOGGER << v;
        }
    }
 
    std::forward_list<int> intForwardList;
    ret = cmd->get("--forwardlistint", intForwardList);
    if (ret)
    {
        for (auto &v : intForwardList)
        {
            LOGGER << v;
        }
    }
 
    std::multiset<std::string> strMultiset;
    ret = cmd->get("--multisetstring", strMultiset);
    if (ret)
    {
        for (auto &v : strMultiset)
        {
            LOGGER << v;
        }
    }
 
    std::multiset<int> intMultiset;
    ret = cmd->get("--multisetint", intMultiset);
    if (ret)
    {
        for (auto &v : intMultiset)
        {
            LOGGER << v;
        }
    }
 
    std::unordered_set<std::string> strUnorderedset;
    ret = cmd->get("--unorderedsetstring", strUnorderedset);
    if (ret)
    {
        for (auto &v : strUnorderedset)
        {
            LOGGER << v;
        }
    }
 
    std::unordered_set<int> intUnorderedset;
    ret = cmd->get("--unorderdsetint", intUnorderedset);
    if (ret)
    {
        for (auto &v : intUnorderedset)
        {
            LOGGER << v;
        }
    }
 
    std::unordered_multiset<std::string> strUnorderedmultiset;
    ret = cmd->get("--unorderedmsetstring", strUnorderedmultiset);
    if (ret)
    {
        for (auto &v : strUnorderedmultiset)
        {
            LOGGER << v;
        }
    }
 
    std::unordered_multiset<int> intUnorderedmultiset;
    ret = cmd->get("--unorderdmsetint", intUnorderedmultiset);
    if (ret)
    {
        for (auto &v : intUnorderedmultiset)
        {
            LOGGER << LogFormat::addr << v;
        }
    }
}

 接口演示：www.soo6.net

class CmdLine
{
public:
    CmdLine() = default;
    ~CmdLine() = default;
     
    /**
     * @brief add 设置命令行选项以及附带参数
     * @Param shortName 选项短名称
     * @param name 选项长名称
     * @param describtion 选项描述
     * @param dep 可选参数,选项依赖
     * @param range 可选参数,参数范围
     * @Return 返回无
     */
    template<//STL_T是用户定义的数据类型，有可能是容器，但也有可能不是
             typename STL_T = None<int>,
             //STL_STR是选项依赖的数据类型。它是个容器，内部类型使用std::string
             //具体使用哪个容器与STL_T容器保持一致，如果STL_T不是容器则默认使用list
             typename STL_STR = STL_NEW_T<STL_T, std::string>,
             //STL_R是参数范围的数据类型。它是个容器,内部类型与用户容器内部类型保持一致
             //具体使用哪个容器与STL_T容器保持一致，如果STL_T不是容器则默认使用list
             typename STL_R = STL_NEW_T<STL_T, typename IsStl<STL_T>::FinalT>>
    void add(const std::string &shortName, const std::string &name,
             const std::string &describtion, STL_STR dep = STL_STR(), 
             STL_R range = STL_R())
    {
        paramTable.emplace_back(std::make_shared<ParamWithValue<STL_T>>(name, 
                                                 shortName, describtion, dep, 
                                                 range));
    }
 
    /**
     * @brief get 获取选项信息，或者获取参数信息,注意参数只能获取一次
     * @param name 选项名称
     * @param t  获取参数信息
     * @return 返回 选项使能 true 否则 false
     */
    template<typename STL_T = None<int>>
    bool get(const std::string &name, STL_T &&t = STL_T())
    {
        for (auto &l : paramTable)
        {
            if ((l->getName() == name || l->getShortName() == name) &&
                 l->getEnable())
            {
                //移除STL_T多余的类型修饰信息，const volatile等等。
                using STL_T_ = RemoveCVREF<STL_T>;
                auto p = std::dynamic_pointer_cast<ParamWithValue<STL_T_>>(l);
                t = std::move(p->get());
                return true;
            }
        }
        return false;
    }
 
    /**
     * @brief parse 解析命令行参数
     * @param noParam 没有命令行参数，是否继续运行，true ：是 false: 否
     * @param argc 命令行参数数量
     * @param argv 命令行参数列表
     * @return 返回 选项使能 true 否则 false
     */
    void parse(bool noParam, int argc, char *argv[]);
 
private:
    void showHelp();
    void paramCheck();
 
private:
    std::list<std::shared_ptr<ParamBase>> paramTable;
    std::string cmd;
};

头条百科
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CmdParser, 一个简单而轻量级的使用C++11的命令行 解析器.zip
10-10
CmdParser, 一个简单而轻量级的使用C++11的命令行 解析器 简单的C++ 命令行 解析器这个项目提供了一个简单的。单头的命令行分析器。 它非常轻量级并且依赖模板。 最简单的方法是将它添加到源代码中。 解析器需要 C++11，在 gcc ( 。v4.8.2或者更高版本，一些早期版本也应该能正常工作)
4.9 C++ Boost 命令行解析库
CSDN
08-22 4556
property_tree 是 Boost 库中的一个头文件库，用于处理和解析基于 XML、Json 或者 INFO 格式的数据。 property_tree 可以提供一个轻量级的、灵活的、基于二叉数的通用容器，可以处理包括简单值（如 int、float）和复杂数据结构（如结构体和嵌套容器）在内的各种数据类型。它可以解析数据文件到内存中，然后通过迭代器访问它们。
github开源项目cxxopts一个轻量级c++命令行解析器分析文档（基于README）
最新发布
2401_85012620的博客
05-17 426
另一个是。
C++ 命令行解析库TCLAP
zhghost的专栏
12-29 746
介绍一个命令行解析库：TCLAP，属于一个比较好用的命令行解析库，Envoy中也用到了这个库，整理出来，方便后续查看。详细介绍参考：https://tclap.sourceforge.net/html/classTCLAP_1_1SwitchArg.html使用方法分成几步：先初始化一些默认的参数数值，parse传递过来的参数之后，会使用传递进来的参数代替掉这些默认值。//step1:实例化...
mian中argv命令行解析代码C++
weixin_43360707的博客
10-21 563
我们在写一个命令行程序的时候，在main文件中有时候要解析传入main文件中的argc argv，现在我提供一个比较简单的案例，先看看它的使用方式： 使用起来就是这么简单，下面是三个文件的代码：mvx_list.h mvx_argparse.h mvx_argparse.c
命令行解析辅助类
01-18
命令行解析辅助类，说明见readme.txt，支持的模式：-c/--command/-cparam/-c param/--command param
cpp-ncargparse是一个用C编写的命令行参数解析器
08-16
cpp-ncargparse是一个专为C语言设计的命令行参数解析库，它的主要目标是帮助开发者轻松处理程序启动时从命令行接收的各种参数。在C或C++开发中，尤其是在构建命令行界面（CLI）工具时，正确解析和管理这些参数至关...
cpp-clipp用于现代C的命令行参数解析
08-16
标题 "cpp-clipp用于现代C++的命令行参数解析" 提到的是一个专门用于处理C++程序命令行参数解析的库。cpp-clipp是一个高效、灵活且强大的工具，旨在简化开发人员在创建命令行应用程序时处理输入参数的过程。在C++...
c++实现通用参数解析类示例
09-04
总结来说，这个示例提供了C++中处理命令行参数的一种解决方案，通过创建一个参数解析类，可以更方便地管理和验证用户输入的参数。这在开发命令行工具或者需要接收复杂配置的程序时非常有用。这样的设计允许程序...
cpW.rar_C++ 命令行工具_文件复制
09-24
在本文中，我们将深入探讨如何使用C++编程语言在Windows环境下开发一个命令行工具，用于实现文件复制功能。这个工具的源代码文件名为`cpW.c`，它利用了Windows API来实现文件操作。 首先，我们需要理解C++命令行...
04GFLAGS-命令行参数解析的作用-windows
10-12
总之，GFLAGS是Caffe在Windows环境中实现命令行参数解析的关键工具，它简化了配置过程，增强了程序的可定制性。正确理解和使用GFLAGS，对于在Windows上成功搭建和运行Caffe至关重要。同时，安装Caffe的依赖库也是一...
c++命令行解析开源库cxxopts上手教程
性感的小君君
04-12 928
具体规则请看代码注释，总体来说还是比较通俗易懂的，不需要特别多的解释。// 1. 导入头文件（只有一个）// 2. 创建一个Options实例// 3. 写入可解析的参数("d,debug", "Enable debugging") // 默认是bool类型("i,integer", "Int param", cxxopts::value<int>()) // 该参数是int类型// vector 传递参数有 2 种方式// --value_list=1,2,3,4 一次性传递，确保没有空格。
C++ vector 赋值
博客
01-09 2141
vectorivec1(10,42); //内置方法，初始化的内容为10个42 print(ivec1.begin(),ivec1.end()); vectorivec2(10); vector::size_type ix=0; for(ix;ix<10;++ix) { ivec2[ix]=42; //下标操作 } print(ivec2.begin(),ivec2.end
一种基于C++STL库的回溯排列组合枚举器
丁劲犇技术发布空间
04-22 1906
在指导学生入门信息学竞赛的过程中，遇到最多的问题就是排列组合。当代信息学竞赛不鼓励学生们采用强力的语言特性来解决问题，一般建议首先从算法本身思考，尽量避免利用排列组合算法实施穷尽（这样的方法往往报超时）。 但如何快速的实现排列组合枚举这个问题本身，可以作为知识点来训练学生的基本功。这里我分享一个学生写的程序，基本框架完全没变，一些变量命名与代码风格我帮忙稍作规整。程序包括排列（Pn,mPn,mP......
C++ Boost库 实现命令行解析
CSDN
02-26 1万+
Boost库中默认自带了一个功能强大的命令行参数解析器，以往我都是自己实现参数解析的，今天偶尔发现这个好东西，就来总结一下参数解析的基本用法，该库需要引入。命令行下使用help输出帮助菜单，当传入三个参数时，即可解析到第二个判断上，执行相应的函数即可。头文件，即可使用了。
【C++】cmdline——轻量级的C++命令行解析库
weixin_30399821的博客
12-10 894
1、说明 cmdline是一个轻量级的c++命令行参数解析工具，全部源码只有一个cmdline.h头文件。 2、代码 20171210_命令行进行解析.cpp // 20171210_命令行进行解析.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "cmdline.h" #include <iostream> us...
【C++】clipp 一个命令行参数解析器
郭老二
03-16 3219
1、简介 clipp是一个使用方便、功能强大的命令行解析器，源码只有一个头文件《clipp.h》 github地址：https://github.com/muellan/clipp 2、使用 只演示最简单的例子，更复杂的参见源码中《README.md》。 例如需要如下命令行参数 用法： convert <input file> [-r] [-o <output forma...
【C++】cmdline —— 轻量级的C++命令行解析库
热门推荐
业精于勤荒于嬉，行成于思毁于随
10-26 1万+
平时用C++写一些命令行工具，需要解析命令行的输入参数，这是一项繁琐并且容易出错的工作，我们不应该将主要精力放在这上面，可以考虑使用开源的库，下面的cmdline就是其中非常好用的一款。cmdline 是一个非常简单好用的C++命令行解析库，其基于模板，所以使用很简单，写出的代码也很优雅。由于其只包含一个头文件，所以很容易集成到自己的项目中。
C++程序设计：main函数形参解析与命令行参数
C++是在C语言基础上发展起来的，增加了面向对象编程的概念，如类、对象、继承、多态等特性，使其成为一个更强大的编程工具。 C语言的主要特点包括： 1. 结构化编程：C语言支持结构化编程，使得程序结构清晰，易于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值