C++如何实现一个命令行解析库_从零开始设计一个灵活的C++命令行参数处理器

class Option {
public:
    std::vector<std::string> names;  // 支持 -v, --verbose
    std::string help;
    bool required = false;
    bool has_value = true;
    bool parsed = false;
<pre class='brush:php;toolbar:false;'>virtual ~Option() = default;
virtual bool parse(std::vector<std::string>::iterator& it,
                   std::vector<std::string>::iterator end) = 0;
virtual void reset() { parsed = false; }

template<typename T>
class TypedOption : public Option {
public:
    T* value_ptr;
    T default_value;
<pre class='brush:php;toolbar:false;'>TypedOption(T* ptr, const T& def)
    : value_ptr(ptr), default_value(def) {
    *value_ptr = def;
    has_value = true;
}

bool parse(std::vector<std::string>::iterator& it,
           std::vector<std::string>::iterator end) override {
    if (it == end) return false;

    std::string val = *it;
    // 处理 --key=value 形式
    for (auto& name : names) {
        size_t eq = name.length() + 1;
        if (val.length() > eq && val[name.length()] == '=' &&
            val.substr(0, eq-1) == name) {
            val = val.substr(eq);
            ++it;
            return from_string(val);
        }
    }
    // 正常情况：下一个参数是值
    ++it;
    return from_string(val);
}

class CommandLineParser {
    std::vector<std::unique_ptr<Option>> options;
    std::string prog_name;
    std::string description;
<p>public:
void set_description(const std::string& desc) {
description = desc;
}</p><pre class='brush:php;toolbar:false;'>template<typename T>
auto add_option(T* value, const std::initializer_list<std::string>& names)
    -> TypedOption<T>& {
    auto opt = std::make_unique<TypedOption<T>>(value, T{});
    opt->names.assign(names.begin(), names.end());
    auto& ref = *opt;
    options.push_back(std::move(opt));
    return ref;
}

bool parse(int argc, char* argv[]) {
    std::vector<std::string> args(argv + 1, argv + argc);
    prog_name = argv[0];

    for (auto it = args.begin(); it != args.end();) {
        std::string token = *it;

        if (token == "--") {
            ++it;
            break;
        }
        if (token.length() >= 2 && token[0] == '-') {
            bool matched = false;
            for (auto& opt : options) {
                for (auto& name : opt->names) {
                    if ((name.length() == 1 && token == "-" + name) ||
                        (name.length() > 1 && token == "--" + name)) {
                        ++it;
                        if (!opt->parse(it, args.end())) {
                            std::cerr << "Invalid value for " << name << "\n";
                            return false;
                        }
                        matched = true;
                        break;
                    }
                }
                if (matched) break;
            }
            if (!matched) {
                std::cerr << "Unknown option: " << token << "\n";
                return false;
            }
        } else {
            // 位置参数暂不处理
            ++it;
        }
    }

    // 检查必填项
    for (auto& opt : options) {
        if (opt->required && !opt->parsed) {
            std::cerr << "Missing required option: ";
            for (auto& n : opt->names) std::cerr << "-" << n << " ";
            std::cerr << "\n";
            return false;
        }
    }

    return true;
}

void print_help() {
    std::cout << "Usage: " << prog_name << " [OPTIONS]\n";
    if (!description.empty())
        std::cout << description << "\n\n";

    std::cout << "Options:\n";
    for (auto& opt : options) {
        std::cout << "  ";
        for (size_t i = 0; i < opt->names.size(); ++i) {
            if (i) std::cout << ", ";
            std::cout << (opt->names[i].length() == 1 ?
                        "-" : "--") << opt->names[i];
        }
        if (opt->has_value) std::cout << " VALUE";
        std::cout << "\n      " << opt->help << "\n";
    }
}

int main(int argc, char* argv[]) {
    int port = 8080;
    std::string host = "localhost";
    bool verbose = false;
    double timeout = 5.0;
<pre class='brush:php;toolbar:false;'>CommandLineParser parser;
parser.set_description("A simple server launcher");

parser.add_option(&port, {"p", "port"})
       .help = "Set server port";
parser.add_option(&host, {"h", "host"})
       .help = "Set server host";
parser.add_option(&verbose, {"v", "verbose"})
       .help = "Enable verbose logging";
parser.add_option(&timeout, {"timeout"})
       .help = "Set request timeout in seconds";

if (argc == 1) {
    parser.print_help();
    return 0;
}

if (!parser.parse(argc, argv)) {
    parser.print_help();
    return 1;
}

// 使用解析后的值
std::cout << "Starting server on " << host << ":" << port
          << " (timeout=" << timeout << "s, verbose=" << verbose << ")\n";

return 0;