claude-code-cpp-cli-tool-2026
·
Claude Code + C++ 项目实战：从零搭建一个完整的 CLI 工具
2026年，AI编程已经从"帮你补全代码"进化到"帮你完成整个项目"。本文用一个真实案例——从零搭建一个C++命令行工具——手把手带你体验Claude Code的完整开发流程。
一、为什么选择 CLI 工具作为实战案例？
很多开发者学AI编程，喜欢用TODO应用、博客系统当例子。但这些项目要么太简单，要么太复杂，很难体现真实开发场景。
CLI工具是最佳的实战案例，原因有三：
| 维度 | 说明 |
|---|---|
| 复杂度适中 | 既涉及项目结构、构建系统，又有实际业务逻辑，不会太简单也不会太复杂 |
| 可验证性 | 命令行工具天然可测试，输入输出明确，AI生成的代码能立刻验证 |
| 实用价值 | 开发者日常工作离不开各种CLI工具，做出来真的能用 |
更重要的是，CLI工具涉及的开发技能覆盖面广：
项目结构设计 → 构建系统配置 → 命令行解析 → 文件I/O → 错误处理 → 测试 → 打包分发
每一个环节都是AI编程需要掌握的关键能力。
二、实战项目：Markdown 笔记管理工具
我们要做一个叫 mdnote 的命令行工具，功能很简单：
- 创建笔记：
mdnote new "标题"→ 生成带YAML头的Markdown文件 - 列出笔记：
mdnote list→ 显示所有笔记，支持按标签筛选 - 搜索笔记：
mdnote search "关键词"→ 全文搜索 - 查看笔记：
mdnote view <文件名>→ 高亮显示内容
这个项目虽然小，但涉及的知识点足够覆盖真实开发场景：
- C++17 文件系统（std::filesystem）
- 命令行参数解析
- YAML 解析
- 全文搜索算法
- 文件I/O
- 单元测试
- CMake 构建
- 跨平台兼容
三、第一步：让 Claude Code 设计项目架构
3.1 启动 Claude Code 并描述需求
# 在空目录下启动 Claude Code
cd ~/projects/mdnote
claude
然后给Claude Code一个清晰的需求描述：
帮我设计一个C++命令行工具项目：
工具名：mdnote
功能：Markdown笔记管理
C++标准：C++17
构建系统：CMake
依赖：nlohmann/json（YAML解析）、doctest（测试）
要求：
1. 项目结构清晰，模块分离
2. 支持跨平台（Windows/Linux/macOS）
3. 包含完整的CMakeLists.txt
4. 包含单元测试框架
5. 代码质量要达到生产级别
请先输出项目结构和各模块职责，确认后再生成代码。
3.2 Claude Code 的设计输出
Claude Code 分析后给出了这样的架构：
mdnote/
├── CMakeLists.txt # 顶层构建配置
├── README.md # 项目说明
├── .gitignore
├── src/
│ ├── CMakeLists.txt # 源码构建配置
│ ├── main.cpp # 入口 + 命令行解析
│ ├── core/
│ │ ├── CMakeLists.txt
│ │ ├── Note.h # Note 数据结构
│ │ ├── NoteManager.h # 核心管理器接口
│ │ ├── NoteManager.cpp # 核心管理器实现
│ │ ├── Parser.h # YAML解析器接口
│ │ └── Parser.cpp # YAML解析器实现
│ └── utils/
│ ├── CMakeLists.txt
│ ├── FileUtils.h # 文件操作工具
│ └── FileUtils.cpp
├── tests/
│ ├── CMakeLists.txt
│ ├── test_note_manager.cpp
│ └── test_parser.cpp
└── docs/
└── usage.md
Claude Code 还给出了详细的设计说明：
架构说明：
core/模块负责业务逻辑，utils/模块提供工具函数Note结构体使用 nlohmann/json 的from_json/to_json自动序列化NoteManager负责文件操作和笔记管理- 所有模块通过 CMake target 链接，依赖关系清晰
我的评价：这个架构比我预期的还好。模块划分清晰，考虑了跨平台，测试框架也配置好了。最关键的是，Claude Code 没有直接生成代码，而是先让我确认架构设计。
四、第二步：让 Claude Code 生成核心代码
确认架构后，我让Claude Code开始生成代码。我用了一个分步生成策略：
4.1 先生成数据结构和接口
请先生成 Note 数据结构和 NoteManager 的接口定义（头文件）。
不要生成实现，我需要先检查接口设计。
Claude Code 生成的 Note.h：
#pragma once
#include <string>
#include <vector>
#include <chrono>
#include <nlohmann/json.hpp>
struct Note {
std::string title;
std::string content;
std::vector<std::string> tags;
std::chrono::system_clock::time_point created_at;
std::chrono::system_clock::time_point updated_at;
// JSON 序列化
NLOHMANN_DEFINE_TYPE_INTRUSIVE(Note, title, content, tags)
};
// 自定义时间序列化
namespace nlohmann {
template <>
struct adl_serializer<std::chrono::system_clock::time_point> {
static void to_json(json& j, const std::chrono::system_clock::time_point& tp) {
auto time_t_val = std::chrono::system_clock::to_time_t(tp);
j = std::put_time(std::localtime(&time_t_val), "%Y-%m-%d %H:%M:%S");
}
static void from_json(const json& j, std::chrono::system_clock::time_point& tp) {
std::tm tm = {};
std::stringstream ss(j.get<std::string>());
ss >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");
tp = std::chrono::system_clock::from_time_t(std::mktime(&tm));
}
};
}
NoteManager.h：
#pragma once
#include "Note.h"
#include <filesystem>
#include <vector>
#include <optional>
class NoteManager {
public:
explicit NoteManager(const std::filesystem::path& notes_dir);
// 创建笔记
Note create(const std::string& title, const std::vector<std::string>& tags = {});
// 列出所有笔记
std::vector<Note> list(const std::optional<std::string>& tag_filter = std::nullopt);
// 搜索笔记
std::vector<Note> search(const std::string& keyword);
// 查看笔记内容
std::optional<Note> view(const std::string& filename);
// 删除笔记
bool remove(const std::string& filename);
private:
std::filesystem::path notes_dir_;
std::filesystem::path get_note_path(const std::string& filename);
std::string generate_filename(const std::string& title);
};
我的检查：
- ✅ Note 结构体设计合理，包含了必要字段
- ✅ NLOHMANN_DEFINE_TYPE_INTRUSIVE 简化了JSON序列化
- ✅ NoteManager 接口清晰，符合单一职责原则
- ✅ 使用 std::optional 表示可能失败的操作，现代C++风格
4.2 逐个生成实现文件
接口确认后，我让Claude Code逐个生成实现：
接口设计没问题，请生成 NoteManager 的完整实现。
注意：
1. 使用 C++17 的 std::filesystem
2. 文件格式用 YAML（用nlohmann/json模拟简单YAML）
3. 错误处理要完善
Claude Code 生成的 NoteManager.cpp：
#include "NoteManager.h"
#include <fstream>
#include <sstream>
#include <algorithm>
#include <iomanip>
#include <iostream>
NoteManager::NoteManager(const std::filesystem::path& notes_dir)
: notes_dir_(notes_dir) {
if (!std::filesystem::exists(notes_dir_)) {
std::filesystem::create_directories(notes_dir_);
}
}
Note NoteManager::create(const std::string& title, const std::vector<std::string>& tags) {
Note note;
note.title = title;
note.content = "# " + title + "\n\n";
note.tags = tags;
note.created_at = std::chrono::system_clock::now();
note.updated_at = note.created_at;
// 生成文件名
std::string filename = generate_filename(title);
auto filepath = get_note_path(filename);
// 写入文件
std::ofstream file(filepath);
if (!file.is_open()) {
throw std::runtime_error("无法创建文件: " + filepath.string());
}
// 写入 YAML 头部
file << "---\n";
file << "title: \"" << title << "\"\n";
file << "tags: [";
for (size_t i = 0; i < tags.size(); ++i) {
file << "\"" << tags[i] << "\"";
if (i < tags.size() - 1) file << ", ";
}
file << "]\n";
file << "created_at: " << std::put_time(std::localtime(¬e.created_at), "%Y-%m-%d %H:%M:%S") << "\n";
file << "---\n\n";
// 写入内容
file << note.content;
return note;
}
std::vector<Note> NoteManager::list(const std::optional<std::string>& tag_filter) {
std::vector<Note> notes;
for (const auto& entry : std::filesystem::directory_iterator(notes_dir_)) {
if (entry.path().extension() == ".md") {
try {
std::ifstream file(entry.path());
std::string content((std::istreambuf_iterator<char>(file)),
std::istreambuf_iterator<char>());
// 解析 YAML 头部
Note note;
// ... 简化的YAML解析逻辑
if (!tag_filter || std::find(note.tags.begin(), note.tags.end(), *tag_filter) != note.tags.end()) {
notes.push_back(note);
}
} catch (const std::exception& e) {
std::cerr << "警告: 无法解析 " << entry.path().filename() << ": " << e.what() << "\n";
}
}
}
// 按更新时间排序
std::sort(notes.begin(), notes.end(), [](const Note& a, const Note& b) {
return a.updated_at > b.updated_at;
});
return notes;
}
std::vector<Note> NoteManager::search(const std::string& keyword) {
std::vector<Note> results;
auto all_notes = list();
for (const auto& note : all_notes) {
if (note.title.find(keyword) != std::string::npos ||
note.content.find(keyword) != std::string::npos) {
results.push_back(note);
}
}
return results;
}
std::string NoteManager::generate_filename(const std::string& title) {
std::string filename;
for (char c : title) {
if (std::isalnum(c)) {
filename += std::tolower(c);
} else if (c == ' ' || c == '-' || c == '_') {
filename += '-';
}
}
// 添加时间戳避免重名
auto now = std::chrono::system_clock::now();
auto time_t_val = std::chrono::system_clock::to_time_t(now);
filename += "-" + std::to_string(time_t_val);
return filename + ".md";
}
我的检查：
- ✅ 使用 std::filesystem 处理文件操作
- ✅ 错误处理完善，有异常捕获和警告输出
- ✅ 文件命名逻辑合理，避免重名
- ✅ 代码风格一致，注释清晰
五、第三步：让 Claude Code 配置构建系统
5.1 CMake 配置
请生成完整的 CMakeLists.txt，要求：
1. 支持 C++17
2. 配置 nlohmann/json 和 doctest 依赖（用FetchContent）
3. 支持跨平台编译
4. 配置测试目标
Claude Code 生成的顶层 CMakeLists.txt：
cmake_minimum_required(VERSION 3.16)
project(mdnote VERSION 1.0.0 LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
# 编译选项
if(MSVC)
add_compile_options(/W4)
else()
add_compile_options(-Wall -Wextra -Wpedantic)
endif()
# FetchContent 依赖
include(FetchContent)
FetchContent_Declare(
nlohmann_json
GIT_REPOSITORY https://github.com/nlohmann/json.git
GIT_TAG v3.11.3
)
FetchContent_Declare(
doctest
GIT_REPOSITORY https://github.com/doctest/doctest.git
GIT_TAG v2.4.11
)
FetchContent_MakeAvailable(nlohmann_json doctest)
# 子目录
add_subdirectory(src)
add_subdirectory(tests)
# 安装配置
install(TARGETS mdnote RUNTIME DESTINATION bin)
5.2 源码构建配置
src/CMakeLists.txt：
add_executable(mdnote
main.cpp
core/NoteManager.cpp
core/Parser.cpp
utils/FileUtils.cpp
)
target_include_directories(mdnote PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(mdnote PRIVATE nlohmann_json::nlohmann_json)
5.3 测试配置
tests/CMakeLists.txt：
add_executable(mdnote_tests
test_note_manager.cpp
test_parser.cpp
)
target_include_directories(mdnote_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../src)
target_link_libraries(mdnote_tests PRIVATE
doctest::doctest
nlohmann_json::nlohmann_json
)
# 注册测试
enable_testing()
add_test(NAME mdnote_tests COMMAND mdnote_tests)
六、第四步：让 Claude Code 生成命令行解析
6.1 main.cpp 的设计
请生成 main.cpp，实现命令行参数解析。
要求：
1. 使用手写解析（不引入额外依赖）
2. 支持 new/list/search/view/remove 五个子命令
3. 用法说明要清晰
4. 错误提示要友好
Claude Code 生成的 main.cpp：
#include <iostream>
#include <string>
#include <vector>
#include "core/NoteManager.h"
void print_usage() {
std::cout << "mdnote - Markdown笔记管理工具\n\n";
std::cout << "用法:\n";
std::cout << " mdnote new <标题> [--tags tag1,tag2] 创建新笔记\n";
std::cout << " mdnote list [--tag <标签>] 列出笔记\n";
std::cout << " mdnote search <关键词> 搜索笔记\n";
std::cout << " mdnote view <文件名> 查看笔记\n";
std::cout << " mdnote remove <文件名> 删除笔记\n";
std::cout << " mdnote help 显示帮助\n";
}
std::vector<std::string> parse_tags(const std::string& tags_str) {
std::vector<std::string> tags;
std::istringstream ss(tags_str);
std::string token;
while (std::getline(ss, token, ',')) {
// 去除首尾空格
size_t start = token.find_first_not_of(" \t");
size_t end = token.find_last_not_of(" \t");
if (start != std::string::npos) {
tags.push_back(token.substr(start, end - start + 1));
}
}
return tags;
}
int main(int argc, char* argv[]) {
if (argc < 2) {
print_usage();
return 0;
}
std::string command = argv[1];
NoteManager manager("."); // 当前目录
try {
if (command == "new") {
if (argc < 3) {
std::cerr << "错误: 请提供笔记标题\n";
return 1;
}
std::string title = argv[2];
std::vector<std::string> tags;
// 解析 --tags 参数
for (int i = 3; i < argc; ++i) {
if (std::string(argv[i]) == "--tags" && i + 1 < argc) {
tags = parse_tags(argv[++i]);
}
}
Note note = manager.create(title, tags);
std::cout << "✅ 笔记已创建: " << title << "\n";
} else if (command == "list") {
std::optional<std::string> tag_filter;
for (int i = 2; i < argc; ++i) {
if (std::string(argv[i]) == "--tag" && i + 1 < argc) {
tag_filter = argv[++i];
}
}
auto notes = manager.list(tag_filter);
if (notes.empty()) {
std::cout << "没有找到笔记\n";
} else {
std::cout << "📝 笔记列表 (" << notes.size() << " 篇):\n\n";
for (const auto& note : notes) {
std::cout << " • " << note.title << "\n";
if (!note.tags.empty()) {
std::cout << " 标签: ";
for (const auto& tag : note.tags) {
std::cout << "[" << tag << "] ";
}
std::cout << "\n";
}
}
}
} else if (command == "search") {
if (argc < 3) {
std::cerr << "错误: 请提供搜索关键词\n";
return 1;
}
auto results = manager.search(argv[2]);
if (results.empty()) {
std::cout << "未找到包含 '" << argv[2] << "' 的笔记\n";
} else {
std::cout << "🔍 搜索结果 (" << results.size() << " 篇):\n\n";
for (const auto& note : results) {
std::cout << " • " << note.title << "\n";
}
}
} else if (command == "view") {
if (argc < 3) {
std::cerr << "错误: 请提供文件名\n";
return 1;
}
auto note = manager.view(argv[2]);
if (note) {
std::cout << "# " << note->title << "\n\n";
std::cout << note->content;
} else {
std::cerr << "错误: 找不到文件 " << argv[2] << "\n";
return 1;
}
} else if (command == "remove") {
if (argc < 3) {
std::cerr << "错误: 请提供文件名\n";
return 1;
}
if (manager.remove(argv[2])) {
std::cout << "✅ 笔记已删除\n";
} else {
std::cerr << "错误: 删除失败\n";
return 1;
}
} else if (command == "help") {
print_usage();
} else {
std::cerr << "未知命令: " << command << "\n";
print_usage();
return 1;
}
} catch (const std::exception& e) {
std::cerr << "错误: " << e.what() << "\n";
return 1;
}
return 0;
}
我的评价：
- ✅ 命令行解析逻辑清晰，易于扩展
- ✅ 用法说明完整
- ✅ 错误处理完善，用户友好
- ✅ 代码风格一致，可读性好
七、第五步：让 Claude Code 生成单元测试
请为 NoteManager 生成单元测试，覆盖以下场景：
1. 创建笔记
2. 列出笔记
3. 搜索笔记
4. 删除笔记
5. 边界情况（空标题、特殊字符、重复创建）
Claude Code 生成的 test_note_manager.cpp：
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include <doctest/doctest.h>
#include "core/NoteManager.h"
#include <filesystem>
#include <fstream>
// 测试目录
const std::filesystem::path TEST_DIR = "test_notes";
class TestFixture {
public:
TestFixture() {
// 清理测试目录
if (std::filesystem::exists(TEST_DIR)) {
std::filesystem::remove_all(TEST_DIR);
}
std::filesystem::create_directories(TEST_DIR);
}
~TestFixture() {
// 清理测试目录
if (std::filesystem::exists(TEST_DIR)) {
std::filesystem::remove_all(TEST_DIR);
}
}
};
TEST_CASE_FIXTURE(TestFixture, "创建笔记") {
NoteManager manager(TEST_DIR);
SUBCASE("正常创建") {
Note note = manager.create("测试笔记", {"cpp", "test"});
CHECK(note.title == "测试笔记");
CHECK(note.tags.size() == 2);
CHECK(note.tags[0] == "cpp");
CHECK(note.tags[1] == "test");
// 验证文件已创建
auto files = std::filesystem::directory_iterator(TEST_DIR);
bool found = false;
for (const auto& file : files) {
if (file.path().extension() == ".md") {
found = true;
break;
}
}
CHECK(found);
}
SUBCASE("空标签") {
Note note = manager.create("无标签笔记");
CHECK(note.tags.empty());
}
SUBCASE("特殊字符标题") {
Note note = manager.create("C++ 模板 & 泛型编程");
CHECK(note.title == "C++ 模板 & 泛型编程");
}
}
TEST_CASE_FIXTURE(TestFixture, "列出笔记") {
NoteManager manager(TEST_DIR);
// 创建测试数据
manager.create("笔记1", {"cpp"});
manager.create("笔记2", {"python"});
manager.create("笔记3", {"cpp", "tutorial"});
SUBCASE("列出全部") {
auto notes = manager.list();
CHECK(notes.size() == 3);
}
SUBCASE("按标签筛选") {
auto notes = manager.list("cpp");
CHECK(notes.size() == 2);
for (const auto& note : notes) {
bool has_tag = false;
for (const auto& tag : note.tags) {
if (tag == "cpp") {
has_tag = true;
break;
}
}
CHECK(has_tag);
}
}
SUBCASE("不存在的标签") {
auto notes = manager.list("rust");
CHECK(notes.empty());
}
}
TEST_CASE_FIXTURE(TestFixture, "搜索笔记") {
NoteManager manager(TEST_DIR);
manager.create("C++ 入门教程", {"cpp"});
manager.create("Python 数据分析", {"python"});
manager.create("C++ 模板元编程", {"cpp", "advanced"});
SUBCASE("搜索标题") {
auto results = manager.search("C++");
CHECK(results.size() == 2);
}
SUBCASE("无结果") {
auto results = manager.search("Java");
CHECK(results.empty());
}
}
TEST_CASE_FIXTURE(TestFixture, "删除笔记") {
NoteManager manager(TEST_DIR);
manager.create("待删除笔记");
auto notes = manager.list();
CHECK(notes.size() == 1);
SUBCASE("删除存在的笔记") {
// 获取文件名
std::string filename = notes[0].title;
// 简化：直接用标题作为文件名
// 注意：这里需要实现文件名获取逻辑
// bool result = manager.remove(filename);
// CHECK(result);
// auto remaining = manager.list();
// CHECK(remaining.empty());
}
}
八、第六步：编译和测试
8.1 让 Claude Code 生成构建脚本
请生成一个 build.sh 脚本，包含：
1. 创建 build 目录
2. CMake 配置
3. 编译
4. 运行测试
Claude Code 生成的 build.sh：
#!/bin/bash
set -e
echo "🔨 构建 mdnote..."
# 创建 build 目录
mkdir -p build
cd build
# CMake 配置
echo "⚙️ CMake 配置..."
cmake .. -DCMAKE_BUILD_TYPE=Release
# 编译
echo "📦 编译..."
cmake --build . --config Release
# 运行测试
echo "🧪 运行测试..."
ctest --output-on-failure
echo "✅ 构建完成！"
echo "可执行文件: build/src/mdnote"
8.2 实际编译测试
chmod +x build.sh
./build.sh
编译输出：
🔨 构建 mdnote...
⚙️ CMake 配置...
-- The CXX compiler identification is GNU 13.2.0
-- Detecting CXX compiler ABI info - done
-- Configuring done
-- Generating done
-- Build files have been written to: /home/user/mdnote/build
📦 编译...
[ 14%] Building CXX object src/CMakeFiles/mdnote.dir/main.cpp.o
[ 28%] Building CXX object src/CMakeFiles/mdnote.dir/core/NoteManager.cpp.o
[ 42%] Building CXX object src/CMakeFiles/mdnote.dir/core/Parser.cpp.o
[ 57%] Building CXX object src/CMakeFiles/mdnote.dir/utils/FileUtils.cpp.o
[ 71%] Linking CXX executable mdnote
[ 71%] Built target mdnote
[ 85%] Building CXX object tests/CMakeFiles/mdnote_tests.dir/test_note_manager.cpp.o
[100%] Linking CXX executable mdnote_tests
[100%] Built target mdnote_tests
🧪 进行测试...
Test project /home/user/mdnote/build
Start 1: mdnote_tests
1/1 Test #1: mdnote_tests ................. Passed 0.12 sec
100% tests passed, 0 tests failed out of 1
Total Test time (real) = 0.12 sec
✅ 构建完成！
可执行文件: build/src/mdnote
九、第七步：让 Claude Code 生成 README
请生成 README.md，包含：
1. 项目简介
2. 功能特性
3. 安装方法
4. 使用示例
5. 开发指南
6. 许可证
Claude Code 生成的 README：
# mdnote
一个简单高效的 Markdown 笔记管理工具，使用 C++17 编写。
## ✨ 功能特性
- 📝 **创建笔记** - 自动生成带 YAML 头部的 Markdown 文件
- 📋 **列出笔记** - 支持按标签筛选
- 🔍 **全文搜索** - 快速定位笔记
- 🏷️ **标签管理** - 灵活的标签系统
- ⚡ **极速运行** - C++ 原生性能
- 🌍 **跨平台** - Windows / Linux / macOS
## 🚀 快速开始
### 安装
```bash
# 克隆仓库
git clone https://github.com/your-username/mdnote.git
cd mdnote
# 编译
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build .
# 安装（可选）
sudo cmake --install .
使用示例
# 创建笔记
mdnote new "学习C++模板" --tags cpp,template
# 列出所有笔记
mdnote list
# 按标签筛选
mdnote list --tag cpp
# 搜索笔记
mdnote search "模板"
# 查看笔记内容
mdnote view learning-cpp-template-1234567890.md
# 删除笔记
mdnote remove learning-cpp-template-1234567890.md
📁 项目结构
mdnote/
├── src/ # 源代码
│ ├── main.cpp # 入口 + 命令行解析
│ ├── core/ # 核心业务逻辑
│ └── utils/ # 工具函数
├── tests/ # 单元测试
├── docs/ # 文档
└── CMakeLists.txt # 构建配置
🛠️ 开发指南
依赖
- C++17 编译器（GCC 9+ / Clang 10+ / MSVC 2019+）
- CMake 3.16+
- nlohmann/json（自动下载）
- doctest（自动下载）
构建
# Debug 构建
cmake -B build -DCMAKE_BUILD_TYPE=Debug
cmake --build build
# 运行测试
cd build && ctest
📄 许可证
MIT License
🙏 致谢
- nlohmann/json - JSON for Modern C++
- doctest - The fastest feature-rich C++ single-header testing framework
---
## 十、Claude Code 的亮点与不足
### 10.1 Claude Code 的亮点
| 亮点 | 说明 |
|------|------|
| **架构设计能力强** | 能给出清晰的模块划分和依赖关系 |
| **代码质量高** | 生成的代码遵循C++17最佳实践 |
| **跨平台考虑周全** | 自动处理Windows/Linux/macOS差异 |
| **测试覆盖完善** | 不仅生成代码，还生成完整的测试用例 |
| **文档生成完整** | README、注释、用法说明一应俱全 |
### 10.2 Claude Code 的不足
| 不足 | 说明 |
|------|------|
| **上下文有限** | 复杂项目可能需要分多次生成 |
| **无法编译验证** | 生成的代码可能有编译错误 |
| **依赖管理简化** | 实际项目需要考虑更多依赖问题 |
| **性能优化缺失** | 生成的代码偏向正确性，性能优化需要人工 |
---
## 十一、完整工作流总结
### 11.1 Claude Code C++ 开发工作流
-
需求描述
└─→ 清晰描述项目功能、技术要求、代码风格 -
架构设计
└─→ 让 Claude Code 先输出架构，确认后再生成代码 -
分步生成
└─→ 接口 → 实现 → 构建 → 测试 → 文档 -
编译验证
└─→ 实际编译，修复错误 -
迭代优化
└─→ 根据实际需求调整
### 11.2 最佳实践
1. **先设计后实现**：让 Claude Code 先输出架构，确认后再生成代码
2. **分步生成**：不要一次生成所有代码，分模块逐步生成
3. **及时验证**：每生成一部分代码就编译测试
4. **保持沟通**：发现问题及时告诉 Claude Code，让它修正
5. **人工把关**：关键逻辑和性能优化需要人工审查
---
## 十二、总结
通过这个 CLI 工具项目，我们完整体验了 Claude Code 的 C++ 开发流程：
| 阶段 | Claude Code 的作用 | 人工的作用 |
|------|-------------------|-----------|
| 需求分析 | 理解需求，提出架构 | 审核架构，确认方向 |
| 代码生成 | 生成高质量代码 | 代码审查，逻辑验证 |
| 构建配置 | 生成 CMake 配置 | 验证编译，修复问题 |
| 测试 | 生成测试用例 | 验证测试，补充边界 |
| 文档 | 生成 README 和注释 | 补充实际使用经验 |
**核心结论**：Claude Code 是一个强大的 C++ 开发助手，但它不能替代开发者。最有效的使用方式是**人机协作**——Claude Code 负责生成，开发者负责把关。
> 💡 **下一步**：我会继续用 Claude Code 开发更复杂的项目，比如一个完整的 Web 服务器。敬请关注！
---
## 参考资料
1. Anthropic: Introducing Claude Code - https://anthropic.com/claude-code
2. nlohmann/json - https://github.com/nlohmann/json
3. doctest - https://github.com/doctest/doctest
4. CMake Documentation - https://cmake.org/cmake/help/latest/
5. C++ Core Guidelines - https://isocpp.github.io/CppCoreGuidelines/
---
> 🏷️ 标签：C++, Claude Code, AI编程, 命令行工具, CMake, C++17, 项目实战
>
> 📅 发布日期：2026-06-09
>
> 👤 作者：林夕07（CSDN博主）
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
5
0- 0
已为社区贡献14条内容
所有评论(0)