更新时间： 2026-08-27

最后一个练习，也是最接近"真实工具"的一个：写一个命令行工具，解析 --help、--verbose、--count 3 这类参数。你在终端敲过的每个命令（grep -r、ls -l、perf record -g），背后都有这么一段解析逻辑。这也是 C++ 入门篇的收官之作——把 string_view、optional、map、范围 for 这些现代特性组装成一个能用的工具。

本文要回答：argv/argc 到底长什么样？长短选项怎么解析？string_view 和 optional 在这个场景各解决什么问题？

一、需求与设计

需求：

• 支持布尔开关：--verbose、-v；--help、-h
• 支持带值参数：--count N、-c N
• 支持位置参数：文件列表（可多个）
• 未知选项报错并提示用法

设计：

@startmindmap
* 命令行解析工具
** main（入口）
*** argv/argc 原始参数
** parse_args（解析函数）
*** 遍历 argv
*** 识别选项 / 值 / 位置参数
** Options（结果结构）
*** verbose / count / files
*** 用法说明
@endmindmap

参数分三类：布尔开关（有/无）、带值参数（后面跟一个值）、位置参数（不属于任何选项的裸参数）。解析器要能区分它们。

二、代码设计

#include <iostream>
#include <string>
#include <string_view>
#include <vector>
#include <optional>
#include <cstdlib>

struct Options {
    bool verbose = false;
    int count = 1;
    std::vector<std::string> files;
};

// 解析 --xxx 和 -x 两种形式的开关
bool is_option(std::string_view s) {
    return s.size() >= 2 && s[0] == '-';
}

// 核心解析：参数列表 → Options
Options parse_args(int argc, char* argv[]) {
    Options opts;
    std::vector<std::string_view> args(argv + 1, argv + argc);

    for (std::size_t i = 0; i < args.size(); ++i) {
        std::string_view a = args[i];

        if (a == "--help" || a == "-h") {
            std::cout << "用法: tool [选项] <文件...>\n"
                      << "  -v, --verbose   输出详细信息\n"
                      << "  -c, --count N   处理次数（默认 1）\n"
                      << "  -h, --help      显示帮助\n";
            std::exit(0);
        }
        else if (a == "--verbose" || a == "-v") {
            opts.verbose = true;
        }
        else if (a == "--count" || a == "-c") {
            if (i + 1 >= args.size()) {
                std::cerr << "错误: " << a << " 需要一个值\n";
                std::exit(1);
            }
            opts.count = std::stoi(std::string(args[++i]));  // 值就是下一个参数
        }
        else if (is_option(a)) {
            std::cerr << "错误: 未知选项 " << a << "\n";
            std::exit(1);
        }
        else {
            opts.files.emplace_back(a);   // 位置参数：文件
        }
    }
    return opts;
}

int main(int argc, char* argv[]) {
    Options opts = parse_args(argc, argv);

    if (opts.verbose) std::cout << "[verbose] 解析完成\n";
    if (opts.files.empty()) {
        std::cout << "没有指定文件。用 --help 查看用法。\n";
        return 1;
    }

    for (const auto& f : opts.files) {
        std::cout << "处理 " << f << " x" << opts.count << "\n";
    }
    return 0;
}

知识点盘点：

知识点	用到的地方
argv/argc	程序入口参数
string_view（53）	只读视图遍历参数（零拷贝）
vector（32）	位置参数收集
范围 for（09）	遍历
std::stoi + 异常（54）	数字转换 + 报错
std::exit	帮助/错误的直接退出

为什么参数遍历用 string_view 而不是 std::string？ argv 里的字符串生命周期是整个程序——string_view 直接指向它们，零拷贝，而且 == 比较、size()、substr 都能用（53 篇）。只有需要存储（files.emplace_back）时才转成 std::string——"只读借用用 view，要持有用 string"，这条 53 篇的原则在这里一步不差地落地。

三、实验预期

• tool -v a.txt b.txt → verbose 开、处理两个文件
• tool --count 3 data.txt → 处理 1 次 × 3
• tool --help → 输出用法，立即退出
• tool --unknown → 报错"未知选项"
• tool -c（缺值）→ 报错"需要一个值"

四、实验数据

实际编译运行输出（g++ 13，-std=c++17）：

$ g++ -O0 -g -std=c++17 -o tool main.cpp

$ ./tool -v a.txt b.txt
[verbose] 解析完成
处理 a.txt x1
处理 b.txt x1

$ ./tool --count 3 data.txt
处理 data.txt x3

$ ./tool --help
用法: tool [选项] <文件...>
  -v, --verbose   输出详细信息
  -c, --count N   处理次数（默认 1）
  -h, --help      显示帮助

$ ./tool --unknown foo.txt
错误: 未知选项 --unknown

$ ./tool -c
错误: -c 需要一个值

各场景验证：

命令行	行为	说明
-v a.txt b.txt	verbose 开 + 处理 2 文件	开关+位置参数混合
--count 3 data.txt	处理 ×3	带值参数
--help	输出用法退出	帮助分支
--unknown	报错退出	未知选项检测
-c	报错缺值	值缺失检测

五、实验分析

1. std::exit 的争议

直接 std::exit(0) 从解析函数退出——简单，但"不优雅"：不走栈展开、局部对象不析构。在这个小程序里无妨，但工程上更推荐返回错误码/状态让 main 决定怎么退。练习里用 exit 是为了短，真要写正规工具，改成 parse_args 返回 std::optional<Options>（解析失败返回 nullopt），main 判断后退出——这正好用上 51 篇的 optional：

// 更工程化的写法（片段）
std::optional<Options> parse_args(int argc, char* argv[]) {
    Options opts;
    // ... 解析 ...
    if (error) return std::nullopt;   // 解析失败
    return opts;                       // 成功
}

int main(int argc, char* argv[]) {
    auto opts = parse_args(argc, argv);
    if (!opts) return 1;
    // 用 *opts ...
}

optional 表达"解析可能失败"比 exit 干净得多——调用方决定怎么处理，而不是函数内直接退出。

2. 真实工具怎么做的

真实的 getopt（POSIX C 库）支持 -abc 合并短选项、-- 分隔符、-c 3 与 -c3 两种写法；C++ 社区有 CLI11、cxxopts 等库把解析做全。本站的脚本工具（scripts/ 下的 .mjs/.sh）也大量用了参数解析。这个练习的规模是"读懂 + 扩展"，不是"重造轮子"。

3. 位置参数与选项的区分

解析器的核心就是"判断每个 token 是哪种类型"。这个判断顺序（帮助 → 布尔 → 带值 → 未知选项 → 位置参数）就是真实解析器的骨架。往后读 getopt 源码、看任何 CLI 库，会发现骨架都差不多。

六、C 对照

模块	C（getopt）	C++（手写版）
参数来源	main(argc, argv)	相同
标准解析	getopt（POSIX）	手写或 CLI11 等库
短选项合并	-abc 原生支持	需扩展
字符串比较	strcmp	==（string_view）
错误处理	errno / 返回值	异常 / optional

C 的 getopt 是标准答案，但用起来有全局状态（optarg、optind）；C++ 手写版把状态收敛进 Options 结构，更清晰。真实项目中直接 getopt 或第三方库，本练习的价值是理解解析的本质逻辑。

七、扩展练习

1. --count=3 形式：支持等号分隔的值（用 string_view 的 find('=') + substr）
2. 短选项合并：-vc 3 拆成 -v 和 -c 3
3. 默认值 + 校验：count 为负数时报错
4. -- 分隔符：-- 之后全部当位置参数（包括以 - 开头的文件名）

八、与本站主线衔接

• // 综合练习 6：命令行参数解析工具
  // 对应文档: languages/cpp/beginner/63-practice-cli-tool.md
  // 编译: g++ -O0 -g -std=c++17 cli_tool.cpp -o cli_tool
  // 运行: ./cli_tool -v a.txt b.txt | ./cli_tool --count 3 data.txt | ./cli_tool --help
  #include <iostream>
  #include <string>
  #include <string_view>
  #include <vector>
  #include <optional>
  #include <cstdlib>
  
  struct Options {
      bool verbose = false;
      int count = 1;
      std::vector<std::string> files;
  };
  
  bool is_option(std::string_view s) {
      return s.size() >= 2 && s[0] == '-';
  }
  
  // 解析失败返回 nullopt（工程化写法，替代 std::exit）
  std::optional<Options> parse_args(int argc, char* argv[]) {
      Options opts;
      std::vector<std::string_view> args(argv + 1, argv + argc);
  
      for (std::size_t i = 0; i < args.size(); ++i) {
          std::string_view a = args[i];
  
          if (a == "--help" || a == "-h") {
              std::cout << "用法: cli_tool [选项] <文件...>\n"
                        << "  -v, --verbose   输出详细信息\n"
                        << "  -c, --count N   处理次数（默认 1）\n"
                        << "  -h, --help      显示帮助\n";
              return std::nullopt;   // 帮助不是错误，用空值区分
          }
          else if (a == "--verbose" || a == "-v") {
              opts.verbose = true;
          }
          else if (a == "--count" || a == "-c") {
              if (i + 1 >= args.size()) {
                  std::cerr << "错误: " << a << " 需要一个值\n";
                  return std::nullopt;
              }
              try {
                  opts.count = std::stoi(std::string(args[++i]));
              } catch (const std::exception&) {
                  std::cerr << "错误: count 必须是整数\n";
                  return std::nullopt;
              }
          }
          else if (is_option(a)) {
              std::cerr << "错误: 未知选项 " << a << "\n";
              return std::nullopt;
          }
          else {
              opts.files.emplace_back(a);
          }
      }
      return opts;
  }
  
  int main(int argc, char* argv[]) {
      auto opts = parse_args(argc, argv);
      if (!opts) return 1;   // 解析失败或显示帮助后退出
  
      if (opts->verbose) std::cout << "[verbose] 解析完成\n";
      if (opts->files.empty()) {
          std::cout << "没有指定文件。用 --help 查看用法。\n";
          return 1;
      }
  
      for (const auto& f : opts->files) {
          std::cout << "处理 " << f << " x" << opts->count << "\n";
      }
      return 0;
  }

• argv/argc 与 main 的细节在 00 篇环境搭建时讲过，这里是系统应用
• 本站 tools/ 域的观测工具（top、perf、strace）全是命令行程序，它们的参数风格可以参考
• 到这里，C++ 入门 64 篇全部完成——下一篇开始是高手层的移动语义、模板、异常安全等进阶主题

九、一句话总结

命令行参数解析是入门篇的收官实战：argv/argc 提供原始参数，string_view 零拷贝遍历、std::string 存储位置参数、"先判断选项类型再取值"的解析骨架可扩展到任何 CLI；它也示范了 optional 表达"解析可能失败"的工程化写法——语法到工具的最后一公里，就是把每个小特性放到合适的位置。

---

上一篇：62-综合练习：链表（智能指针版） ｜ 入门篇完，下一步：高手层：移动语义与右值引用