使cmdline 支持 解析一个参数多个值

已于 2022-09-12 14:40:29 修改
阅读量668 收藏 2
点赞数 1
文章标签： c++
于 2022-09-12 14:28:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hidxl/article/details/126813647
版权

使cmdline 支持 解析一个参数多个值

使cmdline 支持 解析一个参数多个值

cmdline是一个轻量级的c++命令行参数解析工具，全部源码只有一个cmdline.h头文件，使用起来非常方便，关于如何使用它，不是本文讨论的重点,本文讨论,如果修改该文件,使其支持记录一个参数的多个值

修改parser

parser中增加返回参数的个数

  template <class T>
  size_t count(const std::string &name)const{
    if (options.count(name)==0) throw cmdline_error("there is no flag: --"+name);
    const option_with_value<T> *p=dynamic_cast<const option_with_value<T>*>(options.find(name)->second);
    if (p==NULL) throw cmdline_error("type mismatch flag '"+name+"'");
    return p->count();
  }

修改 get 函数,增加索引获取指定的参数

  template <class T>
  const T &get(const std::string &name,size_t idx=0) const {
    if (options.count(name)==0) throw cmdline_error("there is no flag: --"+name);
    const option_with_value<T> *p=dynamic_cast<const option_with_value<T>*>(options.find(name)->second);
    if (p==NULL) throw cmdline_error("type mismatch flag '"+name+"'");
    return p->get(idx);
  }

修改option_with_value模板类

template <class T>
  class option_with_value : public option_base {
  public:
    option_with_value(const std::string &name,
                      char short_name,
                      bool need,
                      const T &def,
                      const std::string &desc)
      : nam(name), snam(short_name), need(need), has(false)
      , def(def){
        actuals.push_back(def);
      this->desc=full_description(desc);
    }
    ~option_with_value(){}

    const T &get(size_t idx) const {
      if(idx>=actuals.size()) throw cmdline::cmdline_error("index_outrange_error");
      tmp= actuals[idx];
      return tmp;
    }

    bool has_value() const { return true; }

    bool set(){
      return false;
    }

    bool set(const std::string &value){
      try{
        auto actual=read(value);
        if(!has){actuals.clear();}
        actuals.push_back(actual);
        has=true;
      }
      catch(const std::exception &){
        return false;
      }
      return true;
    }
    
    bool has_set() const{
      return has;
    }
    size_t count()const{return actuals.size();}
    bool valid() const{
      if (need && !has) return false;
      return true;
    }

    bool must() const{
      return need;
    }

    const std::string &name() const{
      return nam;
    }

    char short_name() const{
      return snam;
    }

    const std::string &description() const {
      return desc;
    }

    std::string short_description() const{
      return "--"+nam+"="+detail::readable_typename<T>();
    }

  protected:
    std::string full_description(const std::string &desc){
      return
        desc+" ("+detail::readable_typename<T>()+
        (need?"":" [="+detail::default_value<T>(def)+"]")
        +")";
    }

    virtual T read(const std::string &s)=0;

    std::string nam;
    char snam;
    bool need;
    std::string desc;

    bool has;
    T def;
    mutable  T tmp;
    std::vector<T> actuals;
  };

完整代码如下

/*
  Copyright (c) 2009, Hideyuki Tanaka
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
  * Redistributions of source code must retain the above copyright
  notice, this list of conditions and the following disclaimer.
  * Redistributions in binary form must reproduce the above copyright
  notice, this list of conditions and the following disclaimer in the
  documentation and/or other materials provided with the distribution.
  * Neither the name of the <organization> nor the
  names of its contributors may be used to endorse or promote products
  derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY <copyright holder> ''AS IS'' AND ANY
  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#pragma once

#include <iostream>
#include <sstream>
#include <vector>
#include <map>
#include <string>
#include <stdexcept>
#include <typeinfo>
#include <cstring>
#include <algorithm>
#ifndef _MSC_VER
#include <cxxabi.h>
#endif
#include <cstdlib>

namespace cmdline{

namespace detail{

template <typename Target, typename Source, bool Same>
class lexical_cast_t{
public:
  static Target cast(const Source &arg){
    Target ret;
    std::stringstream ss;
    if (!(ss<<arg && ss>>ret && ss.eof()))
      throw std::bad_cast();
    
    return ret;
  }
};

template <typename Target, typename Source>
class lexical_cast_t<Target, Source, true>{
public:
  static Target cast(const Source &arg){
    return arg;
  }  
};

template <typename Source>
class lexical_cast_t<std::string, Source, false>{
public:
  static std::string cast(const Source &arg){
    std::ostringstream ss;
    ss<<arg;
    return ss.str();
  }
};

template <typename Target>
class lexical_cast_t<Target, std::string, false>{
public:
  static Target cast(const std::string &arg){
    Target ret;
    std::istringstream ss(arg);
    if (!(ss>>ret && ss.eof()))
      throw std::bad_cast();
    return ret;
  }
};

template <typename T1, typename T2>
struct is_same {
  static const bool value = false;
};

template <typename T>
struct is_same<T, T>{
  static const bool value = true;
};

template<typename Target, typename Source>
Target lexical_cast(const Source &arg)
{
  return lexical_cast_t<Target, Source, detail::is_same<Target, Source>::value>::cast(arg);
}

static inline std::string demangle(const std::string &name)
{
#ifdef _MSC_VER
  return name;
#elif defined(__GNUC__)
  int status=0;
  char *p=abi::__cxa_demangle(name.c_str(), 0, 0, &status);
  std::string ret(p);
  free(p);
  return ret;
#else
#error unexpected c complier (msvc/gcc)
#endif
}

template <class T>
std::string readable_typename()
{
  return demangle(typeid(T).name());
}

template <class T>
std::string default_value(T def)
{
  return detail::lexical_cast<std::string>(def);
}

template <>
inline std::string readable_typename<std::string>()
{
  return "string";
}

} // detail

//-----

class cmdline_error : public std::exception {
public:
  cmdline_error(const std::string &msg): msg(msg){}
  ~cmdline_error() throw() {}
  const char *what() const throw() { return msg.c_str(); }
private:
  std::string msg;
};

template <class T>
struct default_reader{
  T operator()(const std::string &str){
    return detail::lexical_cast<T>(str);
  }
};

template <class T>
struct range_reader{
  range_reader(const T &low, const T &high): low(low), high(high) {}
  T operator()(const std::string &s) const {
    T ret=default_reader<T>()(s);
    if (!(ret>=low && ret<=high)) throw cmdline::cmdline_error("range_error");
    return ret;
  }
private:
  T low, high;
};

template <class T>
range_reader<T> range(const T &low, const T &high)
{
  return range_reader<T>(low, high);
}

template <class T>
struct oneof_reader{
  T operator()(const std::string &s){
    T ret=default_reader<T>()(s);
    if (std::find(alt.begin(), alt.end(), ret)==alt.end())
      throw cmdline_error("");
    return ret;
  }
  void add(const T &v){ alt.push_back(v); }
private:
  std::vector<T> alt;
};

template <class T>
oneof_reader<T> oneof(T a1)
{
  oneof_reader<T> ret;
  ret.add(a1);
  return ret;
}

template <class T>
oneof_reader<T> oneof(T a1, T a2)
{
  oneof_reader<T> ret;
  ret.add(a1);
  ret.add(a2);
  return ret;
}

template <class T>
oneof_reader<T> oneof(T a1, T a2, T a3)
{
  oneof_reader<T> ret;
  ret.add(a1);
  ret.add(a2);
  ret.add(a3);
  return ret;
}

template <class T>
oneof_reader<T> oneof(T a1, T a2, T a3, T a4)
{
  oneof_reader<T> ret;
  ret.add(a1);
  ret.add(a2);
  ret.add(a3);
  ret.add(a4);
  return ret;
}

template <class T>
oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5)
{
  oneof_reader<T> ret;
  ret.add(a1);
  ret.add(a2);
  ret.add(a3);
  ret.add(a4);
  ret.add(a5);
  return ret;
}

template <class T>
oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6)
{
  oneof_reader<T> ret;
  ret.add(a1);
  ret.add(a2);
  ret.add(a3);
  ret.add(a4);
  ret.add(a5);
  ret.add(a6);
  return ret;
}

template <class T>
oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7)
{
  oneof_reader<T> ret;
  ret.add(a1);
  ret.add(a2);
  ret.add(a3);
  ret.add(a4);
  ret.add(a5);
  ret.add(a6);
  ret.add(a7);
  return ret;
}

template <class T>
oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8)
{
  oneof_reader<T> ret;
  ret.add(a1);
  ret.add(a2);
  ret.add(a3);
  ret.add(a4);
  ret.add(a5);
  ret.add(a6);
  ret.add(a7);
  ret.add(a8);
  return ret;
}

template <class T>
oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8, T a9)
{
  oneof_reader<T> ret;
  ret.add(a1);
  ret.add(a2);
  ret.add(a3);
  ret.add(a4);
  ret.add(a5);
  ret.add(a6);
  ret.add(a7);
  ret.add(a8);
  ret.add(a9);
  return ret;
}

template <class T>
oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8, T a9, T a10)
{
  oneof_reader<T> ret;
  ret.add(a1);
  ret.add(a2);
  ret.add(a3);
  ret.add(a4);
  ret.add(a5);
  ret.add(a6);
  ret.add(a7);
  ret.add(a8);
  ret.add(a9);
  ret.add(a10);
  return ret;
}

//-----

class parser{
public:
  parser(){
  }
  ~parser(){
    for (std::map<std::string, option_base*>::iterator p=options.begin();
         p!=options.end(); p++)
      delete p->second;
  }

  void add(const std::string &name,
           char short_name=0,
           const std::string &desc=""){
    if (options.count(name)) throw cmdline_error("multiple definition: "+name);
    options[name]=new option_without_value(name, short_name, desc);
    ordered.push_back(options[name]);
  }

  template <class T>
  void add(const std::string &name,
           char short_name=0,
           const std::string &desc="",
           bool need=true,
           const T def=T()){
    add(name, short_name, desc, need, def, default_reader<T>());
  }

  template <class T, class F>
  void add(const std::string &name,
           char short_name=0,
           const std::string &desc="",
           bool need=true,
           const T def=T(),
           F reader=F()){
    if (options.count(name)) throw cmdline_error("multiple definition: "+name);
    options[name]=new option_with_value_with_reader<T, F>(name, short_name, need, def, desc, reader);
    ordered.push_back(options[name]);
  }

  void footer(const std::string &f){
    ftr=f;
  }

  void set_program_name(const std::string &name){
    prog_name=name;
  }

  bool exist(const std::string &name) const {
    if (options.count(name)==0) throw cmdline_error("there is no flag: --"+name);
    return options.find(name)->second->has_set();
  }

  template <class T>
  size_t count(const std::string &name)const{
    if (options.count(name)==0) throw cmdline_error("there is no flag: --"+name);
    const option_with_value<T> *p=dynamic_cast<const option_with_value<T>*>(options.find(name)->second);
    if (p==NULL) throw cmdline_error("type mismatch flag '"+name+"'");
    return p->count();
  }
  template <class T>
  const T &get(const std::string &name,size_t idx=0) const {
    if (options.count(name)==0) throw cmdline_error("there is no flag: --"+name);
    const option_with_value<T> *p=dynamic_cast<const option_with_value<T>*>(options.find(name)->second);
    if (p==NULL) throw cmdline_error("type mismatch flag '"+name+"'");
    return p->get(idx);
  }

  const std::vector<std::string> &rest() const {
    return others;
  }

  bool parse(const std::string &arg){
    std::vector<std::string> args;

    std::string buf;
    bool in_quote=false;
    for (std::string::size_type i=0; i<arg.length(); i++){
      if (arg[i]=='\"'){
        in_quote=!in_quote;
        continue;
      }

      if (arg[i]==' ' && !in_quote){
        args.push_back(buf);
        buf="";
        continue;
      }

      if (arg[i]=='\\'){
        i++;
        if (i>=arg.length()){
          errors.push_back("unexpected occurrence of '\\' at end of string");
          return false;
        }
      }

      buf+=arg[i];
    }

    if (in_quote){
      errors.push_back("quote is not closed");
      return false;
    }

    if (buf.length()>0)
      args.push_back(buf);

    // for (size_t i=0; i<args.size(); i++)
    //   std::cout<<"\""<<args[i]<<"\""<<std::endl;

    return parse(args);
  }

  bool parse(const std::vector<std::string> &args){
    int argc=static_cast<int>(args.size());
    std::vector<const char*> argv(argc);

    for (int i=0; i<argc; i++)
      argv[i]=args[i].c_str();

    return parse(argc, &argv[0]);
  }

  bool parse(int argc, const char * const argv[]){
    errors.clear();
    others.clear();

    if (argc<1){
      errors.push_back("argument number must be longer than 0");
      return false;
    }
    if (prog_name=="")
      prog_name=argv[0];

    std::map<char, std::string> lookup;
    for (std::map<std::string, option_base*>::iterator p=options.begin();
         p!=options.end(); p++){
      if (p->first.length()==0) continue;
      char initial=p->second->short_name();
      if (initial){
        if (lookup.count(initial)>0){
          lookup[initial]="";
          errors.push_back(std::string("short option '")+initial+"' is ambiguous");
          return false;
        }
        else lookup[initial]=p->first;
      }
    }

    for (int i=1; i<argc; i++){
      if (strncmp(argv[i], "--", 2)==0){
        const char *p=strchr(argv[i]+2, '=');
        if (p){
          std::string name(argv[i]+2, p);
          std::string val(p+1);
          set_option(name, val);
        }
        else{
          std::string name(argv[i]+2);
          if (options.count(name)==0){
            errors.push_back("undefined option: --"+name);
            continue;
          }
          if (options[name]->has_value()){
            if (i+1>=argc){
              errors.push_back("option needs value: --"+name);
              continue;
            }
            else{
              i++;
              set_option(name, argv[i]);
            }
          }
          else{
            set_option(name);
          }
        }
      }
      else if (strncmp(argv[i], "-", 1)==0){
        if (!argv[i][1]) continue;
        char last=argv[i][1];
        for (int j=2; argv[i][j]; j++){
          last=argv[i][j];
          if (lookup.count(argv[i][j-1])==0){
            errors.push_back(std::string("undefined short option: -")+argv[i][j-1]);
            continue;
          }
          if (lookup[argv[i][j-1]]==""){
            errors.push_back(std::string("ambiguous short option: -")+argv[i][j-1]);
            continue;
          }
          set_option(lookup[argv[i][j-1]]);
        }

        if (lookup.count(last)==0){
          errors.push_back(std::string("undefined short option: -")+last);
          continue;
        }
        if (lookup[last]==""){
          errors.push_back(std::string("ambiguous short option: -")+last);
          continue;
        }

        if (i+1<argc && options[lookup[last]]->has_value()){
          set_option(lookup[last], argv[i+1]);
          i++;
        }
        else{
          set_option(lookup[last]);
        }
      }
      else{
        others.push_back(argv[i]);
      }
    }

    for (std::map<std::string, option_base*>::iterator p=options.begin();
         p!=options.end(); p++)
      if (!p->second->valid())
        errors.push_back("need option: --"+std::string(p->first));

    return errors.size()==0;
  }

  void parse_check(const std::string &arg){
    if (!options.count("help"))
      add("help", '?', "print this message");
    check(0, parse(arg));
  }

  void parse_check(const std::vector<std::string> &args){
    if (!options.count("help"))
      add("help", '?', "print this message");
    check(int(args.size()), parse(args));
  }

  void parse_check(int argc, char *argv[]){
    if (!options.count("help"))
      add("help", '?', "print this message");
    check(argc, parse(argc, argv));
  }

  std::string error() const{
    return errors.size()>0?errors[0]:"";
  }

  std::string error_full() const{
    std::ostringstream oss;
    for (size_t i=0; i<errors.size(); i++)
      oss<<errors[i]<<std::endl;
    return oss.str();
  }

  std::string usage() const {
    std::ostringstream oss;
    oss<<"usage: "<<prog_name<<" ";
    for (size_t i=0; i<ordered.size(); i++){
      if (ordered[i]->must())
        oss<<ordered[i]->short_description()<<" ";
    }
    
    oss<<"[options] ... "<<ftr<<std::endl;
    oss<<"options:"<<std::endl;

    size_t max_width=0;
    for (size_t i=0; i<ordered.size(); i++){
      max_width=(std::max)(max_width, ordered[i]->name().length());
    }
    for (size_t i=0; i<ordered.size(); i++){
      if (ordered[i]->short_name()){
        oss<<"  -"<<ordered[i]->short_name()<<", ";
      }
      else{
        oss<<"      ";
      }

      oss<<"--"<<ordered[i]->name();
      for (size_t j=ordered[i]->name().length(); j<max_width+4; j++)
        oss<<' ';
      oss<<ordered[i]->description()<<std::endl;
    }
    return oss.str();
  }

private:

  void check(int argc, bool ok){
    if ((argc==1 && !ok) || exist("help")){
      std::cerr<<usage();
      exit(0);
    }

    if (!ok){
      std::cerr<<error()<<std::endl<<usage();
      exit(1);
    }
  }

  void set_option(const std::string &name){
    if (options.count(name)==0){
      errors.push_back("undefined option: --"+name);
      return;
    }
    if (!options[name]->set()){
      errors.push_back("option needs value: --"+name);
      return;
    }
  }

  void set_option(const std::string &name, const std::string &value){
    if (options.count(name)==0){
      errors.push_back("undefined option: --"+name);
      return;
    }
    if (!options[name]->set(value)){
      errors.push_back("option value is invalid: --"+name+"="+value);
      return;
    }
  }

  class option_base{
  public:
    virtual ~option_base(){}

    virtual bool has_value() const=0;
    virtual bool set()=0;
    virtual bool set(const std::string &value)=0;
    virtual bool has_set() const=0;
    virtual bool valid() const=0;
    virtual bool must() const=0;

    virtual const std::string &name() const=0;
    virtual char short_name() const=0;
    virtual const std::string &description() const=0;
    virtual std::string short_description() const=0;
  };

  class option_without_value : public option_base {
  public:
    option_without_value(const std::string &name,
                         char short_name,
                         const std::string &desc)
      :nam(name), snam(short_name), desc(desc), has(false){
    }
    ~option_without_value(){}

    bool has_value() const { return false; }

    bool set(){
      has=true;
      return true;
    }

    bool set(const std::string &){
      return false;
    }

    bool has_set() const {
      return has;
    }

    bool valid() const{
      return true;
    }

    bool must() const{
      return false;
    }

    const std::string &name() const{
      return nam;
    }

    char short_name() const{
      return snam;
    }

    const std::string &description() const {
      return desc;
    }

    std::string short_description() const{
      return "--"+nam;
    }

  private:
    std::string nam;
    char snam;
    std::string desc;
    bool has;
  };

  template <class T>
  class option_with_value : public option_base {
  public:
    option_with_value(const std::string &name,
                      char short_name,
                      bool need,
                      const T &def,
                      const std::string &desc)
      : nam(name), snam(short_name), need(need), has(false)
      , def(def){
        actuals.push_back(def);
      this->desc=full_description(desc);
    }
    ~option_with_value(){}

    const T &get(size_t idx) const {
      if(idx>=actuals.size()) throw cmdline::cmdline_error("index_outrange_error");
      tmp= actuals[idx];
      return tmp;
    }

    bool has_value() const { return true; }

    bool set(){
      return false;
    }

    bool set(const std::string &value){
      try{
        auto actual=read(value);
        if(!has){actuals.clear();}
        actuals.push_back(actual);
        has=true;
      }
      catch(const std::exception &){
        return false;
      }
      return true;
    }
    
    bool has_set() const{
      return has;
    }
    size_t count()const{return actuals.size();}
    bool valid() const{
      if (need && !has) return false;
      return true;
    }

    bool must() const{
      return need;
    }

    const std::string &name() const{
      return nam;
    }

    char short_name() const{
      return snam;
    }

    const std::string &description() const {
      return desc;
    }

    std::string short_description() const{
      return "--"+nam+"="+detail::readable_typename<T>();
    }

  protected:
    std::string full_description(const std::string &desc){
      return
        desc+" ("+detail::readable_typename<T>()+
        (need?"":" [="+detail::default_value<T>(def)+"]")
        +")";
    }

    virtual T read(const std::string &s)=0;

    std::string nam;
    char snam;
    bool need;
    std::string desc;

    bool has;
    T def;
    mutable  T tmp;
    std::vector<T> actuals;
  };

  template <class T, class F>
  class option_with_value_with_reader : public option_with_value<T> {
  public:
    option_with_value_with_reader(const std::string &name,
                                  char short_name,
                                  bool need,
                                  const T def,
                                  const std::string &desc,
                                  F reader)
      : option_with_value<T>(name, short_name, need, def, desc), reader(reader){
    }

  private:
    T read(const std::string &s){
      return reader(s);
    }

    F reader;
  };

  std::map<std::string, option_base*> options;
  std::vector<option_base*> ordered;
  std::string ftr;

  std::string prog_name;
  std::vector<std::string> others;

  std::vector<std::string> errors;
};

} // cmdline


// include cmdline.h
//#include "cmdline.h"
/*
static int main_example(int argc, char *argv[])
{
  // create a parser
  cmdline::parser a;

  // 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 mandatory (optional. default is false)
  // 5th argument is default value  (optional. it used when mandatory is false)
  a.add<std::string>("host", 'h', "host name", true, "");

  // 6th argument is extra constraint.
  // Here, port number must be 1 to 65535 by cmdline::range().
  a.add<int>("port", 'p', "port number", false, 80, cmdline::range(1, 65535));

  // cmdline::oneof() can restrict options.
  a.add<std::string>("type", 't', "protocol type", false, "http", cmdline::oneof<string>("http", "https", "ssh", "ftp"));

  // Boolean flags also can be defined.
  // Call add method without a type parameter.
  a.add("gzip", '\0', "gzip when transfer");

  // Run parser.
  // It returns only if command line arguments are valid.
  // If arguments are invalid, a parser output error msgs then exit program.
  // If help flag ('--help' or '-?') is specified, a parser output usage message then exit program.
  a.parse_check(argc, argv);

  // use flag values
  std::cout << a.get<std::string>("type") << "://"
       << a.get<std::string>("host") << ":"
       << a.get<int>("port") << std::endl;

  // boolean flags are referred by calling exist() method.
  if (a.exist("gzip")) std::cout << "gzip" << std::endl;
}
*/
/*
$ ./test
usage: ./test --host=string [options] ...
options:
  -h, --host    host name (string)
  -p, --port    port number (int [=80])
  -t, --type    protocol type (string [=http])
      --gzip    gzip when transfer
  -?, --help    print this message
$ ./test -?
usage: ./test --host=string [options] ...
options:
  -h, --host    host name (string)
  -p, --port    port number (int [=80])
  -t, --type    protocol type (string [=http])
     --gzip    gzip when transfer
  -?, --help    print this message
$ ./test --host=github.com
http://github.com:80
$ ./test --host=github.com -t ftp
ftp://github.com:80
$ ./test --host=github.com -t ttp
option value is invalid: --type=ttp
usage: ./test --host=string [options] ...
options:
  -h, --host    host name (string)
  -p, --port    port number (int [=80])
  -t, --type    protocol type (string [=http])
      --gzip    gzip when transfer
  -?, --help    print this message
$ ./test --host=github.com -p 4545
http://github.com:4545
$ ./test --host=github.com -p 100000
option value is invalid: --port=100000
usage: ./test --host=string [options] ...
options:
  -h, --host    host name (string)
  -p, --port    port number (int [=80])
  -t, --type    protocol type (string [=http])
      --gzip    gzip when transfer
  -?, --help    print this message
$ ./test --host=github.com --gzip
http://github.com:80
gzip
for (int i = 0; i < a.rest().size(); i++)
  cout << a.rest()[i] << endl\;
...
a.footer("filename ...");
...
$ ./test
usage: ./test --host=string [options] ... filename ...
options:
  -h, --host    host name (string)
  -p, --port    port number (int [=80])
  -t, --type    protocol type (string [=http])
      --gzip    gzip when transfer
  -?, --help    print this message
  */

cmdline 源项目

https://github.com/tanakh/cmdline/blob/master/cmdline.h

hidxl
关注
Linux: Kernel: boot cmdline, grub；参数解释
mzhan017的博客
03-23 1516
/arch/x86/kernel/apic/apic.c 这个文件里定义了一些early_param的参数，以及相应的处理函数。 kernel支持的参数： https://www.kernel.org/doc/html/latest/admin-guide/kernel-parameters.html
QEMU源码全解析2 —— QEMU参数解析（2）
phmatthaus的专栏
07-04 896
QEMU源码全解析2 —— QEMU参数解析（2）
cmdline:Lua 的简单命令行参数解析器
06-28
命令行 Lua 的简单命令行参数解析器。 命令行解析器支持长选项 (--foobar) 和短选项 (-f)。 多头期权 '--OPTION=VALUE' 形式的字符串被解析为 { OPTION = 'VALUE' }。 '--OPTION' 形式的字符串被解析为 { OPTION = true }。 多个 '--OPTION=VALUE' 合并为 { OPTION = { 'VALUE', 'VALUE', ... } }。 短期期权 '-O=VALUE' 形式的字符串被解析为 { O = 'VALUE' }。 '-O' 形式的字符串被解析为 { O = true }。 多个 '-O=VALUE' 合并为 { O = { 'VALUE', 'VALUE', ... } }。 参数终止 参数“--”终止所有选项； 任何以下参数都被视为非选项参数，即使它们以连字符开头。 用法 loc
python3.7实现给命令行参数传入多个值
肥仔的博客
07-03 1922
比如想设置个参数，它可以接收多个整数值，那么可以在add_argument中设置action=“append” 调用方式及结果如下： python3.8中还可以用action=“extend”，这样就不需要挨个值前面都跟一个–arg_name了，具体可查看https://docs.python.org/3.9/library/argparse.html#action参考文章： 1.https://blog.csdn.net/qq_38962621/article/details/110579156.....
程序参数解析C/C++库 The Lean Mean C++ Option Parser
Captain--Jack
03-27 785
如果你有意思完全相反的选项（例如–enable foo和–disable foo），你也应该给它们相同的索引，但通过不同的类型值来区分它们。如果您不想使用固定大小的数组（可能会变得太小，导致命令行参数被丢弃），可以使用Stats来确定正确的大小。16.第一个不以“-”开头并且不属于前面的选项的参数将终止选项列表，并且是第一个非选项参数。5.最后一个带参数的短可选项可以和其他的组合，比如： -ABCXfoo -ABCX foo (foo 是-X 可选项的参数)；它用于检查选项是否可以接受潜在的参数。
c++：命令行参数
谁谁谁的的的博客
08-07 332
Google开源的C++库gflags（也称为Google Flags）是一个用于处理命令行参数（flags）的库，它旨在帮助开发人员轻松定义、解析和管理程序的命令行参数。gflags库提供了一种方便的方式来处理程序的配置选项，使得程序的配置更加灵活和易于管理。这会将标志的值设置为相应的参数值，然后程序会输出相应的信息。：除了命令行参数，gflags还支持通过环境变量来设置标志的值，这为程序配置提供了更多的灵活性。：gflags库可以自动生成命令行帮助信息，以便用户在使用程序时了解可用的命令行选项和标志。
4.9 C++ Boost 命令行解析库
CSDN
08-22 4634
property_tree 是 Boost 库中的一个头文件库，用于处理和解析基于 XML、Json 或者 INFO 格式的数据。 property_tree 可以提供一个轻量级的、灵活的、基于二叉数的通用容器，可以处理包括简单值（如 int、float）和复杂数据结构（如结构体和嵌套容器）在内的各种数据类型。它可以解析数据文件到内存中，然后通过迭代器访问它们。
uboot读取adc，通过cmdline传给kernel解析数值，不同硬件模块进行处理
hxHardway的博客
06-15 1405
（1）kernel编译链接，利用.__param .init.setup段将kernel所需参数（driver及通用）和对应处理函数的映射表（obs_kernel_param kernel_param结构体）存放起来。1.首先kernel已经做了cmdline得解析，start_kernel中setup_arch中解析tags获取cmdline，拷贝到boot_command_line中。将cmdline拷贝2份，放在saved_command_line static_command_line。
UE4命令行参数解析
Jerish的博客
12-09 1万+
一 .命令行参数简述 命令行参数是一连串的关键字字符串，当运行可执行文件时可以通过命令行或者可执行文件的快捷方式将其传入。它们的目的是自定义引擎运行的方式，以便符合开发人员或用户的需要。一般用途如下，注：命令行不区分大小写 第一，这可以使得运行编辑器而不运行游戏变得很简单（只要加上几个字符即可，见图1-1）。第二，可以更方便的配置客户端IP，服务器以及其他更丰富的运行信息。第三，它也可以更加复...
arg_parser_1.8（命令行参数解析类库）
10-18
Arg_parser 是一个用来处理命令行参数的C++类，同时也提供C语言的版本。
GetCmdline取命令参数
01-23
用于获取游戏窗口启动命令行参数 实现跳过登录器 直接进入游戏功能！
【C++】cmdline —— 轻量级的C++命令行解析库
热门推荐
业精于勤荒于嬉，行成于思毁于随
10-26 1万+
平时用C++写一些命令行工具，需要解析命令行的输入参数，这是一项繁琐并且容易出错的工作，我们不应该将主要精力放在这上面，可以考虑使用开源的库，下面的cmdline就是其中非常好用的一款。cmdline 是一个非常简单好用的C++命令行解析库，其基于模板，所以使用很简单，写出的代码也很优雅。由于其只包含一个头文件，所以很容易集成到自己的项目中。
c++命令行解析开源库cxxopts上手教程
最新发布
性感的小君君
04-12 1247
具体规则请看代码注释，总体来说还是比较通俗易懂的，不需要特别多的解释。// 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++:改造cmdline用于MSVC下的命令行参数解析
weixin_34159110的博客
08-30 1078
cmdline是一个轻量级的c++命令行参数解析工具，全部源码只有一个cmdline.h头文件，使用起来非常方便，关于如何使用它，不是本文讨论的重点，本文要说的是如何解决cmdline在MSVC下不能编译的问题。你打开下面的cmdline项目托管地址只看首页上的说明就会使用了，另外，如果你看英文比较吃力，这篇博文有全面详细的中文翻译《cmdline —— 轻量级的C++命令行...
svn编译相关
yyour的博客
09-22 609
#include "svn_client.h" #include "svn_cmdline.h" #include "svn_pools.h" #include "svn_config.h" #include "svn_fs.h" #include "svn_wc.h" #include "svn_types.h" /* Display a prompt an
GNU Gengetopt 2.10 Usage
韦编二绝
08-08 1615
GNU Gengetopt 2.10 Usage
C++ 命令行解析库TCLAP
zhghost的专栏
12-29 805
介绍一个命令行解析库：TCLAP，属于一个比较好用的命令行解析库，Envoy中也用到了这个库，整理出来，方便后续查看。详细介绍参考：https://tclap.sourceforge.net/html/classTCLAP_1_1SwitchArg.html使用方法分成几步：先初始化一些默认的参数数值，parse传递过来的参数之后，会使用传递进来的参数代替掉这些默认值。//step1:实例化...
一个不错的命令行参数解析类
weixin_33721427的博客
10-12 179
为什么80%的码农都做不了架构师？>>> ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值