010 《精通 Prompt Engineering：C++ 代码生成实战指南》
备注：Gemini 2.0 Flash Thinking 创作的书籍，用来辅助学习 prompts engineering。
精通 Prompt Engineering：C++ 代码生成实战指南
书籍大纲
▮▮▮▮ chapter 1： 序言与准备
▮▮▮▮▮▮▮ 1.1 Prompt Engineering 概览与 C++ 代码生成
▮▮▮▮▮▮▮ 1.2 为什么选择 Prompt Engineering 进行 C++ 代码生成？
▮▮▮▮▮▮▮ 1.3 本书的目标、结构与阅读建议
▮▮▮▮▮▮▮ 1.4 环境搭建与工具准备
▮▮▮▮▮▮▮ 1.5 Prompt 的基本概念与构成要素
▮▮▮▮ chapter 2： Prompt Engineering 的基础技巧
▮▮▮▮▮▮▮ 2.1 清晰而明确的指令
▮▮▮▮▮▮▮ 2.2 上下文信息的有效利用
▮▮▮▮▮▮▮ 2.3 指定输出格式与结构
▮▮▮▮▮▮▮ 2.4 使用关键词和约束条件
▮▮▮▮▮▮▮ 2.5 迭代优化 Prompt 的流程
▮▮▮▮ chapter 3： C++ 代码生成的核心 Prompt 策略
▮▮▮▮▮▮▮ 3.1 生成基本 C++ 语法结构
▮▮▮▮▮▮▮ 3.2 生成函数和类
▮▮▮▮▮▮▮ 3.3 生成控制流语句
▮▮▮▮▮▮▮ 3.4 生成数据结构
▮▮▮▮▮▮▮ 3.5 生成算法实现
▮▮▮▮ chapter 4： 面向特定任务的 C++ 代码生成实例
▮▮▮▮▮▮▮ 4.1 生成文件操作代码
▮▮▮▮▮▮▮ 4.2 生成字符串处理代码
▮▮▮▮▮▮▮ 4.3 生成网络编程相关代码
▮▮▮▮▮▮▮ 4.4 生成数据库操作代码
▮▮▮▮▮▮▮ 4.5 生成简单的游戏逻辑
▮▮▮▮ chapter 5： 高级 Prompt Engineering 技巧与应用
▮▮▮▮▮▮▮ 5.1 使用 Few-Shot Prompting 进行复杂代码生成
▮▮▮▮▮▮▮ 5.2 利用思维链（Chain of Thought）进行问题分解与代码生成
▮▮▮▮▮▮▮ 5.3 集成外部知识与 API 文档
▮▮▮▮▮▮▮ 5.4 处理代码生成中的错误与异常
▮▮▮▮▮▮▮ 5.5 生成符合特定编码规范的代码
▮▮▮▮ chapter 6： 实战案例分析与启发
▮▮▮▮▮▮▮ 6.1 案例一：快速生成简单的命令行工具
▮▮▮▮▮▮▮ 6.2 案例二：利用 Prompt 生成高效的数据排序算法
▮▮▮▮▮▮▮ 6.3 案例三：使用 Prompt 辅助构建小型 Web 服务器
▮▮▮▮▮▮▮ 6.4 案例四：通过 Prompt 生成嵌入式系统驱动代码片段
▮▮▮▮▮▮▮ 6.5 案例五：利用 Prompt 进行代码重构与优化
▮▮▮▮ chapter 7： Prompt Engineering 在 C++ 项目开发中的应用
▮▮▮▮▮▮▮ 7.1 自动化生成样板代码（Boilerplate Code）
▮▮▮▮▮▮▮ 7.2 辅助生成测试用例（Test Cases）
▮▮▮▮▮▮▮ 7.3 快速生成文档注释（Documentation Comments）
▮▮▮▮▮▮▮ 7.4 利用 Prompt 进行代码审查（Code Review）辅助
▮▮▮▮▮▮▮ 7.5 将 Prompt Engineering 集成到 CI/CD 流程中
▮▮▮▮ chapter 8： Prompt Engineering 的未来趋势与挑战
▮▮▮▮▮▮▮ 8.1 更智能的代码生成模型
▮▮▮▮▮▮▮ 8.2 Prompt Engineering 的自动化与智能化
▮▮▮▮▮▮▮ 8.3 面临的挑战与潜在的解决方案
▮▮▮▮▮▮▮ 8.4 对 C++ 开发者技能的新要求
▮▮▮▮ chapter 9： 总结与展望
▮▮▮▮▮▮▮ 9.1 本书核心知识点回顾
▮▮▮▮▮▮▮ 9.2 Prompt Engineering 在 C++ 开发中的价值
▮▮▮▮▮▮▮ 9.3 对读者的寄语与未来学习建议
1. chapter 1： 序言与准备
1.1 Prompt Engineering 概览与 C++ 代码生成
1.1.1 什么是 Prompt Engineering（提示工程）？
Prompt Engineering（提示工程）是一门新兴的学科，专注于设计和优化输入给大型语言模型（Large Language Models, LLMs）的文本提示（Prompts），以引导模型生成期望的输出。最初，Prompt Engineering 主要应用于自然语言处理（Natural Language Processing, NLP）领域，例如文本生成、翻译、问答等。随着 LLMs 在代码生成方面的能力日益增强，Prompt Engineering 也逐渐扩展到软件开发领域。
1.1.2 Prompt Engineering 在 C++ 代码生成中的意义
在 C++ 代码生成领域，Prompt Engineering 的核心在于利用自然语言描述需求、逻辑或算法，然后通过精心设计的 Prompt 指导 LLM 生成相应的 C++ 代码。相较于传统的编码方式，Prompt Engineering 提供了一种更自然、更高效的代码生成途径，尤其在以下场景中具有显著优势：
① 快速原型开发：通过简单的自然语言描述，快速生成代码框架或核心逻辑，加速原型验证过程。
② 重复性代码生成：对于具有固定模式的样板代码，可以通过 Prompt 自动化生成，减少手动编写的工作量。
③ 辅助代码编写：在编写复杂功能时，利用 Prompt 生成关键代码片段，提高开发效率。
④ 学习与探索：通过观察不同 Prompt 生成的代码，帮助开发者更好地理解 C++ 语法和编程思想。
1.1.3 本书的侧重点
本书将专注于介绍如何运用 Prompt Engineering 技术生成高质量的 C++ 代码。我们将深入探讨各种 Prompt 设计技巧、策略和实战案例，旨在帮助读者掌握利用 LLMs 提升 C++ 开发效率和代码质量的方法。
1.2 为什么选择 Prompt Engineering 进行 C++ 代码生成？
1.2.1 提高开发效率 🚀
传统的 C++ 开发往往需要开发者具备扎实的编程基础和丰富的实践经验。编写代码、调试错误、优化性能等环节都需要耗费大量的时间和精力。Prompt Engineering 的出现，为 C++ 开发带来了新的可能性。通过自然语言描述需求，我们可以让 LLMs 快速生成代码，从而大幅缩短开发周期，提高开发效率。
示例：
假设我们需要一个计算两个整数之和的 C++ 函数。使用传统的开发方式，我们需要编写如下代码：
1
#include <iostream>
2
3
int add(int a, int b) {
4
return a + b;
5
}
6
7
int main() {
8
int num1 = 5;
9
int num2 = 10;
10
int sum = add(num1, num2);
11
std::cout << "The sum is: " << sum << std::endl;
12
return 0;
13
}
而使用 Prompt Engineering，我们只需要向 LLM 输入类似以下的 Prompt：
1
请生成一个 C++ 函数，该函数接收两个整数作为输入，并返回它们的和。同时，编写一个 main 函数来测试这个函数，输入两个整数 5 和 10，并打印结果。
LLM 很有可能生成与上述代码功能相同的 C++ 代码，从而节省了开发者编写基础代码的时间。
1.2.2 降低入门门槛 🚪
C++ 是一门语法相对复杂的编程语言，对于初学者来说，学习曲线较为陡峭。Prompt Engineering 可以作为初学者学习 C++ 的辅助工具。通过观察 LLM 根据 Prompt 生成的代码，初学者可以更快地理解 C++ 的语法规则和编程模式。
1.2.3 激发创新思维 💡
有时，在面对复杂的编程问题时，开发者可能会陷入思维定势。Prompt Engineering 可以通过生成不同的代码实现方案，为开发者提供新的思路和灵感，从而激发创新思维。
1.2.4 自动化重复性任务 🤖
在软件开发过程中，存在许多重复性的任务，例如生成类的 Getter 和 Setter 方法、编写简单的文件读写操作等。这些任务可以通过 Prompt Engineering 自动化完成，从而解放开发者的生产力，让他们能够专注于更具挑战性的工作。
1.3 本书的目标、结构与阅读建议
1.3.1 本书的目标
本书旨在帮助读者：
① 理解 Prompt Engineering 的基本概念和原理。
② 掌握 Prompt Engineering 在 C++ 代码生成中的核心技巧和策略。
③ 能够利用 Prompt Engineering 解决实际 C++ 编程问题。
④ 了解 Prompt Engineering 在 C++ 项目开发中的应用场景和未来发展趋势。
1.3.2 本书的结构
本书共分为九个章节：
① 第一章：序言与准备：介绍 Prompt Engineering 的基本概念、在 C++ 代码生成中的意义，以及本书的目标、结构和阅读建议，并指导读者搭建开发环境。
② 第二章：Prompt Engineering 的基础技巧：讲解设计有效 Prompt 的基本原则和常用技巧。
③ 第三章：C++ 代码生成的核心 Prompt 策略：深入探讨如何使用 Prompt 生成各种 C++ 语法结构、函数、类、控制流、数据结构和算法。
④ 第四章：面向特定任务的 C++ 代码生成实例：通过丰富的实例演示如何使用 Prompt 生成文件操作、字符串处理、网络编程、数据库操作以及简单游戏逻辑等方面的 C++ 代码。
⑤ 第五章：高级 Prompt Engineering 技巧与应用：介绍 Few-Shot Prompting、思维链等高级技巧，以及如何集成外部知识和处理代码生成中的错误。
⑥ 第六章：实战案例分析与启发：通过多个真实的案例分析，展示 Prompt Engineering 在解决实际问题中的应用和价值。
⑦ 第七章：Prompt Engineering 在 C++ 项目开发中的应用：探讨如何将 Prompt Engineering 应用于自动化生成样板代码、测试用例、文档注释以及辅助代码审查等方面。
⑧ 第八章：Prompt Engineering 的未来趋势与挑战：展望 Prompt Engineering 在代码生成领域的发展前景，并分析其面临的挑战。
⑨ 第九章：总结与展望：回顾本书的核心内容，总结 Prompt Engineering 在 C++ 开发中的价值，并为读者提供未来的学习建议。
1.3.3 阅读建议
为了更好地学习本书的内容，建议读者具备一定的 C++ 编程基础。本书侧重于实践，因此建议读者在阅读过程中积极尝试书中的示例，并思考如何将所学的知识应用到自己的项目中。同时，由于 Prompt Engineering 和 LLM 技术仍在快速发展，建议读者保持对最新技术动态的关注。
1.4 环境搭建与工具准备
1.4.1 选择合适的 LLM
目前，有许多强大的 LLMs 可以用于代码生成，例如 OpenAI 的 GPT 系列模型、Google 的 Gemini 系列模型、以及一些开源的模型。读者可以根据自己的需求和资源选择合适的 LLM。本书中的示例将主要基于通用的 LLM 接口进行说明，具体使用哪个模型可以根据实际情况进行调整。
1.4.2 搭建 API 接口
大多数 LLMs 都提供了 API 接口，方便开发者通过编程方式进行调用。读者需要根据所选 LLM 的官方文档，注册账号并获取 API 密钥。通常，可以使用 Python 等编程语言的库来与 API 进行交互。
示例（使用 OpenAI Python 库）：
首先，需要安装 OpenAI Python 库：
1
pip install openai
然后，可以使用以下 Python 代码与 OpenAI API 进行交互：
1
import openai
2
3
# 替换为你的 API 密钥
4
openai.api_key = "YOUR_API_KEY"
5
6
def generate_cpp_code(prompt):
7
response = openai.Completion.create(
8
engine="text-davinci-003", # 选择合适的模型
9
prompt=prompt,
10
max_tokens=200, # 设置生成代码的最大长度
11
n=1, # 生成几个代码片段
12
stop=None, # 设置停止生成的标志
13
temperature=0.7, # 控制生成代码的随机性
14
)
15
return response.choices[0].text.strip()
16
17
if __name__ == "__main__":
18
prompt = "请生成一个计算两个整数乘积的 C++ 函数。"
19
cpp_code = generate_cpp_code(prompt)
20
print(cpp_code)
注意： 请务必妥善保管你的 API 密钥，避免泄露。
1.4.3 集成开发环境（IDE）
虽然 Prompt Engineering 可以帮助我们生成代码，但仍然需要使用集成开发环境（Integrated Development Environment, IDE）来编译、运行和调试生成的 C++ 代码。常用的 C++ IDE 包括：
① Visual Studio（Windows 和 macOS）
② CLion（跨平台）
③ VS Code（跨平台，需要安装 C++ 扩展）
④ Eclipse CDT（跨平台）
读者可以根据自己的喜好和操作系统选择合适的 IDE。
1.5 Prompt 的基本概念与构成要素
1.5.1 什么是 Prompt？
Prompt（提示）是输入给 LLM 的一段文本，用于指导模型生成特定的输出。在 C++ 代码生成领域，Prompt 通常包含对所需代码功能的自然语言描述。
1.5.2 Prompt 的关键构成要素
一个有效的 Prompt 通常包含以下几个关键要素：
① 指令（Instruction）：明确告知模型需要做什么，例如“生成一个函数”、“编写一个类”、“实现一个算法”等。
② 上下文（Context）：提供模型生成代码所需的背景信息，例如已有的代码、数据格式、相关的功能描述等。
③ 输入数据（Input Data）：如果需要模型基于特定的输入生成代码，可以在 Prompt 中提供输入数据。
④ 输出指示（Output Indicator）：明确指定期望的输出格式和结构，例如“返回一个 JSON 格式的字符串”、“代码需要包含注释”等。
示例：
1
指令：请生成一个 C++ 函数。
2
上下文：该函数用于计算一个整数数组的平均值。
3
输入数据：不需要。
4
输出指示：函数应该接收一个整数数组和一个表示数组长度的整数作为输入，并返回一个浮点数表示平均值。代码需要包含适当的注释。
1.5.3 Prompt 的设计原则
设计有效的 Prompt 是 Prompt Engineering 的核心。以下是一些常用的设计原则：
① 清晰性（Clarity）：使用简洁明了的语言描述需求，避免歧义。
② 具体性（Specificity）：尽可能详细地说明所需的功能、逻辑和格式。
③ 相关性（Relevance）：提供的上下文信息应该与生成目标代码高度相关。
④ 约束性（Constraint）：如果对生成的代码有特定的要求（例如使用的库、遵循的编码规范等），需要在 Prompt 中明确指出。
在接下来的章节中，我们将深入探讨如何运用这些基本概念和原则，设计出能够生成高质量 C++ 代码的 Prompt。
2. chapter 2： Prompt Engineering 的基础技巧
2.1 清晰而明确的指令
2.1.1 指令的重要性
Prompt 中的指令是引导 LLM 生成期望输出的首要因素。一个清晰而明确的指令能够直接告诉模型你需要它做什么，从而提高生成结果的准确性和相关性。模糊或含糊不清的指令往往会导致模型产生不符合预期的输出。
2.1.2 如何编写清晰的指令
① 使用动词开头：指令通常以动词开头，例如“生成”、“编写”、“实现”、“创建一个”等，明确表达需要执行的动作。
示例：
- 清晰： “生成一个计算阶乘的 C++ 函数。”
- 模糊： “关于计算阶乘的 C++ 代码。”
② 明确描述功能：清晰地描述所需代码的功能和行为。避免使用过于笼统或抽象的描述。
示例：
- 清晰： “编写一个 C++ 函数，该函数接收一个字符串作为输入，并返回该字符串的长度。”
- 模糊： “生成一个处理字符串的 C++ 代码。”
③ 指定输入和输出：明确指出函数或代码片段的输入参数类型、输出类型以及预期的输出结果。
示例：
- 清晰： “创建一个 C++ 类，该类名为 Rectangle，包含两个私有成员变量 width（整型）和 height（整型），以及一个公有方法 getArea，该方法返回矩形的面积（整型）。”
- 模糊： “写一个关于矩形的 C++ 代码。”
④ 使用具体的术语：使用编程领域中准确的术语，例如“函数”、“类”、“变量”、“循环”、“条件语句”等，避免使用口语化的表达。
示例：
- 清晰： “实现一个使用冒泡排序算法对整型数组进行排序的 C++ 函数。”
- 模糊： “写一个能给数字排序的 C++ 代码。”
2.1.3 实践案例
案例 1：生成一个简单的加法函数
不清晰的 Prompt： “写一个 C++ 加法代码。”
可能的输出（不确定）：
1
// 这可能只是一个简单的 main 函数
2
#include <iostream>
3
4
int main() {
5
int a = 5;
6
int b = 3;
7
int sum = a + b;
8
std::cout << "Sum: " << sum << std::endl;
9
return 0;
10
}
清晰的 Prompt： “生成一个 C++ 函数，该函数接收两个整数作为输入，并返回它们的和。函数名为 add。”
更准确的输出：
1
int add(int a, int b) {
2
return a + b;
3
}
案例 2：生成一个判断素数的函数
不清晰的 Prompt： “写一个 C++ 代码来判断一个数字是不是素数。”
可能的输出（可能包含不必要的细节）：
1
#include <iostream>
2
#include <cmath>
3
4
bool isPrime(int n) {
5
if (n <= 1) return false;
6
for (int i = 2; i <= sqrt(n); i++) {
7
if (n % i == 0) return false;
8
}
9
return true;
10
}
11
12
int main() {
13
int num;
14
std::cout << "Enter a number: ";
15
std::cin >> num;
16
if (isPrime(num)) {
17
std::cout << num << " is a prime number." << std::endl;
18
} else {
19
std::cout << num << " is not a prime number." << std::endl;
20
}
21
return 0;
22
}
清晰的 Prompt： “生成一个 C++ 函数，名为 isPrime，该函数接收一个整数作为输入，并返回一个布尔值，指示该整数是否为素数。”
更简洁且符合要求的输出：
1
bool isPrime(int n) {
2
if (n <= 1) return false;
3
for (int i = 2; i * i <= n; ++i) {
4
if (n % i == 0) return false;
5
}
6
return true;
7
}
通过以上案例可以看出，编写清晰而明确的指令是获得期望 C++ 代码的关键第一步。
2.2 上下文信息的有效利用
2.2.1 上下文信息的重要性
LLMs 在生成代码时，很大程度上依赖于 Prompt 中提供的上下文信息。有效的上下文信息可以帮助模型更好地理解用户的需求，从而生成更准确、更相关的代码。
2.2.2 如何提供有效的上下文信息
① 引入已有的代码：如果需要生成的代码与现有代码库或特定模块进行交互，可以将相关的代码片段包含在 Prompt 中，作为上下文信息。这有助于模型理解代码之间的依赖关系和接口定义。
示例：
假设我们已经有了一个名为 Shape 的基类：
1
// Shape.h
2
#ifndef SHAPE_H
3
#define SHAPE_H
4
5
class Shape {
6
public:
7
virtual double getArea() const = 0;
8
virtual ~Shape() {}
9
};
10
11
#endif
现在，我们希望生成一个继承自 Shape 的 Circle 类。可以在 Prompt 中包含 Shape.h 的内容：
1
请生成一个 C++ 类，名为 `Circle`，它继承自以下 `Shape` 类：
2
3
```cpp
4
// Shape.h
5
#ifndef SHAPE_H
6
#define SHAPE_H
7
8
class Shape {
9
public:
10
virtual double getArea() const = 0;
11
virtual ~Shape() {}
12
};
13
14
#endif
15
```
16
17
`Circle` 类应该包含一个私有成员变量 `radius`（双精度浮点型），以及一个构造函数用于初始化半径，并实现 `getArea()` 方法（返回圆的面积，π * radius * radius）。
LLM 可以根据提供的 Shape 类的定义，生成正确的 Circle 类实现。
② 描述数据结构和格式：如果需要生成的代码处理特定的数据结构或遵循特定的数据格式，可以在 Prompt 中清晰地描述这些信息。
示例：
请生成一个 C++ 函数，该函数接收一个 JSON 格式的字符串作为输入，该字符串表示一个包含 "name"（字符串类型）和 "age"（整型）字段的对象数组。函数应该解析这个 JSON 字符串，并打印出每个对象的 "name" 和 "age"。你需要包含必要的头文件，并使用一个合适的 JSON 解析库（例如 nlohmann/json）。
通过描述输入数据的 JSON 格式，LLM 可以生成正确的解析代码。
③ 提供背景信息和业务逻辑：对于更复杂的代码生成任务，提供相关的背景信息和业务逻辑可以帮助模型更好地理解需求。
示例：
在一个电子商务系统中，我们有一个 `Product` 类，包含 `name`（字符串）、`price`（双精度浮点型）和 `quantity`（整型）等属性。请生成一个 C++ 函数，该函数接收一个 `Product` 对象和一个表示购买数量的整数作为输入，并返回一个表示订单项总价（购买数量 * 商品价格）的双精度浮点数。
提供 Product 类的相关信息，有助于 LLM 生成符合业务逻辑的代码。
2.2.3 注意事项
① 保持上下文信息的简洁性：虽然提供足够的上下文信息很重要，但也要避免在 Prompt 中包含过多不相关的信息，这可能会导致模型产生混淆。
② 确保上下文信息的准确性：提供的上下文信息必须是准确的，否则可能会误导模型生成错误的代码。
2.3 指定输出格式与结构
2.3.1 输出格式的重要性
清晰地指定期望的输出格式和结构，可以帮助 LLM 生成符合特定要求的代码。这在需要将生成的代码集成到现有项目中或需要遵循特定的编码规范时尤为重要。
2.3.2 如何指定输出格式
① 明确指定代码块：可以使用特定的标记（例如 cpp ...）来要求模型生成代码块。
示例：
1
请生成一个 C++ 函数，该函数计算两个整数的最大公约数（GCD）。请将代码放在以下标记中：
2
3
```cpp
4
// 在这里放置你的代码
5
```
② 指定函数签名：如果需要生成一个函数，可以明确指定函数的返回类型、函数名和参数列表。
示例：
请生成一个 C++ 函数，签名为 `int factorial(int n)`，该函数计算给定整数 `n` 的阶乘。
③ 指定类结构：如果需要生成一个类，可以指定类的名称、成员变量、成员函数以及它们的访问修饰符（public、private、protected）。
示例：
请生成一个 C++ 类，名为 `Student`，包含以下私有成员变量：`name`（字符串）、`age`（整型）、`major`（字符串）。同时，包含一个公有的构造函数，用于初始化这些成员变量，以及一个公有的方法 `displayInfo`，用于打印学生的所有信息。
④ 指定注释要求：可以要求模型在生成的代码中包含适当的注释，以提高代码的可读性。
示例：
请生成一个 C++ 函数，该函数实现二分查找算法。要求代码包含详细的注释，解释每个步骤的作用。
⑤ 指定特定的代码风格或规范：如果项目有特定的编码风格或规范要求，可以在 Prompt 中告知模型。
示例：
请生成一个 C++ 函数，该函数将一个字符串转换为大写。请遵循 Google C++ Style Guide。
2.3.3 实践案例
案例 1：生成一个带有指定签名的函数
Prompt： “请生成一个 C++ 函数，签名为 std::string reverseString(const std::string& str)，该函数接收一个字符串作为输入，并返回其反转后的字符串。”
生成的代码：
1
#include <string>
2
#include <algorithm>
3
4
std::string reverseString(const std::string& str) {
5
std::string reversed_str = str;
6
std::reverse(reversed_str.begin(), reversed_str.end());
7
return reversed_str;
8
}
案例 2：生成一个具有特定结构的类
Prompt： “请生成一个 C++ 类，名为 Point，包含两个私有成员变量 x（整型）和 y（整型）。提供一个公有的构造函数，用于初始化 x 和 y，以及两个公有的 Getter 方法 getX() 和 getY()。”
生成的代码：
1
class Point {
2
private:
3
int x;
4
int y;
5
6
public:
7
Point(int x_val, int y_val) : x(x_val), y(y_val) {}
8
9
int getX() const {
10
return x;
11
}
12
13
int getY() const {
14
return y;
15
}
16
};
通过明确指定输出格式和结构，我们可以更好地控制 LLM 生成的 C++ 代码，使其更符合我们的需求。
2.4 使用关键词和约束条件
2.4.1 关键词的重要性
在 Prompt 中使用特定的关键词可以引导 LLM 生成更符合预期的结果。这些关键词可以指示模型关注特定的方面、使用特定的技术或遵循特定的规则。
2.4.2 常用的关键词和约束条件
① 指定编程语言和版本：明确告知模型需要生成 C++ 代码，并可以指定特定的 C++ 版本（例如 C++11、C++14、C++17、C++20）。
示例： “请使用 C++11 标准生成一个…”
② 指定库或框架：如果需要使用特定的库或框架（例如 STL、Boost、Qt、Eigen），可以在 Prompt 中明确指出。
示例： “请使用 STL 中的 std::vector 实现一个…”
③ 指定算法或设计模式：如果需要使用特定的算法（例如快速排序、二分查找）或设计模式（例如单例模式、工厂模式），可以在 Prompt 中进行说明。
示例： “请使用单例模式生成一个 C++ 类…”
④ 指定性能要求：如果对生成的代码有特定的性能要求（例如“高效的”、“低延迟的”），可以在 Prompt 中提及。
示例： “请生成一个高效的 C++ 函数来…”
⑤ 指定安全要求：如果生成的代码需要考虑安全性（例如防止缓冲区溢出、SQL 注入），可以在 Prompt 中强调。
示例： “请生成一个安全的 C++ 函数来处理用户输入…”
⑥ 排除特定的实现方式或技术：有时，我们可能希望避免模型使用某些特定的实现方式或技术，可以在 Prompt 中明确排除。
示例： “请生成一个不使用递归的 C++ 函数来计算阶乘。”
2.4.3 实践案例
案例 1：使用特定库生成代码
Prompt： “请使用 Boost 库中的 boost::asio 生成一个简单的 C++ TCP 客户端，该客户端连接到指定 IP 地址和端口，并发送一条消息。”
生成的代码（可能包含 Boost.Asio 的相关实现）：
1
#include <iostream>
2
#include <boost/asio.hpp>
3
4
using boost::asio::ip::tcp;
5
6
int main() {
7
try {
8
boost::asio::io_context io_context;
9
tcp::resolver resolver(io_context);
10
tcp::resolver::results_type endpoints =
11
resolver.resolve("127.0.0.1", "12345"); // 替换为实际的 IP 地址和端口
12
13
tcp::socket socket(io_context);
14
boost::asio::connect(socket, endpoints);
15
16
std::string message = "Hello from client!";
17
boost::asio::write(socket, boost::asio::buffer(message));
18
19
char reply[1024];
20
boost::asio::read(socket, boost::asio::buffer(reply));
21
std::cout << "Reply from server: " << reply << std::endl;
22
} catch (std::exception& e) {
23
std::cerr << "Exception: " << e.what() << std::endl;
24
}
25
26
return 0;
27
}
案例 2：指定算法生成代码
Prompt： “请生成一个 C++ 函数，使用快速排序算法对一个整数数组进行升序排序。”
生成的代码（可能包含快速排序的实现）：
1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4
5
void quickSort(std::vector<int>& arr, int low, int high) {
6
if (low < high) {
7
int pivot = arr[high];
8
int i = (low - 1);
9
10
for (int j = low; j < high; j++) {
11
if (arr[j] < pivot) {
12
i++;
13
std::swap(arr[i], arr[j]);
14
}
15
}
16
std::swap(arr[i + 1], arr[high]);
17
int pi = i + 1;
18
19
quickSort(arr, low, pi - 1);
20
quickSort(arr, pi + 1, high);
21
}
22
}
23
24
int main() {
25
std::vector<int> data = {10, 7, 8, 9, 1, 5};
26
int n = data.size();
27
quickSort(data, 0, n - 1);
28
std::cout << "Sorted array: ";
29
for (int val : data) {
30
std::cout << val << " ";
31
}
32
std::cout << std::endl;
33
return 0;
34
}
通过合理地使用关键词和约束条件，我们可以更精确地控制 LLM 生成 C++ 代码的行为，使其满足特定的需求。
2.5 迭代优化 Prompt 的流程
2.5.1 为什么需要迭代优化？
即使我们尽力编写清晰、明确且包含足够上下文信息的 Prompt，LLM 生成的代码也可能不完全符合我们的预期。这可能是因为模型对我们的意图理解有偏差，或者生成的代码存在错误、效率不高或者不符合特定的要求。因此，迭代优化 Prompt 是 Prompt Engineering 中一个至关重要的环节。
2.5.2 迭代优化的基本步骤
① 首次尝试并分析结果：首先，根据我们的需求编写一个 Prompt，并让 LLM 生成代码。然后，仔细分析生成的代码，判断它是否满足我们的要求。
② 识别问题和不足：如果生成的代码不理想，我们需要分析问题所在。可能的原因包括：
- Prompt 指令不够清晰或具体。
- 缺乏必要的上下文信息。
- 对输出格式或结构的要求不明确。
- 模型对某些术语或概念的理解与我们不同。
③ 修改和完善 Prompt：根据分析结果，修改和完善我们的 Prompt。这可能包括：
- 更清晰地表达指令。
- 提供更多的上下文信息。
- 更明确地指定输出格式和结构。
- 使用更精确的术语。
- 添加约束条件或排除某些实现方式。
④ 再次尝试并评估结果：修改后的 Prompt 再次输入给 LLM，生成新的代码。然后，再次评估生成结果是否有所改进，是否更接近我们的预期。
⑤ 重复迭代直至满意：重复步骤 ② 到 ④，直到生成的代码达到我们的要求。这个过程可能需要多次迭代。
2.5.3 迭代优化的常用策略
① 逐步细化指令：如果首次尝试的 Prompt 过于宽泛，可以逐步添加更具体的指令，将问题分解为更小的、更易于处理的部分。
② 增加上下文信息：如果模型缺乏必要的背景知识，可以尝试在 Prompt 中提供更多的上下文信息，例如相关的代码片段、数据结构定义、业务逻辑描述等。
③ 调整输出格式要求：如果生成的代码格式不符合要求，可以更明确地指定输出格式，例如使用代码块标记、指定函数签名、定义类结构等。
④ 尝试不同的关键词和约束条件：可以尝试在 Prompt 中添加或修改关键词和约束条件，引导模型生成更符合特定要求的代码。
⑤ 使用 Few-Shot Prompting：对于更复杂的任务，可以尝试提供一些输入-输出的示例（few-shot examples）给模型，帮助它更好地理解任务的要求。我们将在后续章节中详细介绍 Few-Shot Prompting。
⑥ 利用思维链（Chain of Thought）：对于需要复杂推理的任务，可以引导模型逐步思考并解释其生成代码的过程。这有助于我们理解模型的思路，并发现潜在的问题。我们将在后续章节中详细介绍思维链。
2.5.4 实践案例
案例：生成一个计算斐波那契数列的函数
首次尝试的 Prompt： “写一个 C++ 斐波那契函数。”
首次生成的代码（可能不符合要求）：
1
#include <iostream>
2
3
int fibonacci(int n) {
4
if (n <= 1)
5
return n;
6
return fibonacci(n - 1) + fibonacci(n - 2);
7
}
8
9
int main() {
10
int n = 10;
11
std::cout << "Fibonacci(" << n << ") = " << fibonacci(n) << std::endl;
12
return 0;
13
}
分析： 虽然这段代码实现了斐波那契数列的计算，但它同时包含了 main 函数，并且使用了递归实现，效率可能不高。我们的目标可能只是一个返回斐波那契数列指定项的函数。
第二次尝试的 Prompt（更清晰的指令和输出格式要求）： “请生成一个 C++ 函数，名为 getFibonacci，该函数接收一个整数 n 作为输入，并返回斐波那契数列的第 n 项（从 0 开始）。请只生成函数定义，不要包含 main 函数。”
第二次生成的代码：
1
int getFibonacci(int n) {
2
if (n <= 1) {
3
return n;
4
}
5
return getFibonacci(n - 1) + getFibonacci(n - 2);
6
}
分析： 这次生成的代码更符合我们的要求，只包含了函数定义，没有 main 函数。但是，仍然使用了递归实现。
第三次尝试的 Prompt（添加约束条件，要求使用迭代实现）： “请生成一个 C++ 函数，名为 getFibonacciIterative，该函数接收一个整数 n 作为输入，并返回斐波那契数列的第 n 项（从 0 开始）。请使用迭代的方式实现，不要使用递归。”
第三次生成的代码：
1
int getFibonacciIterative(int n) {
2
if (n <= 1) {
3
return n;
4
}
5
int a = 0;
6
int b = 1;
7
for (int i = 2; i <= n; ++i) {
8
int temp = b;
9
b = a + b;
10
a = temp;
11
}
12
return b;
13
}
评估： 这次生成的代码使用迭代方式实现了斐波那契数列的计算，更符合我们可能对效率的要求。
通过这个案例可以看出，迭代优化 Prompt 是一个逐步完善的过程，通过不断地尝试、分析和修改，最终可以获得满足我们需求的 C++ 代码。
在接下来的章节中，我们将学习更多关于 Prompt Engineering 的高级技巧和策略，以及如何将它们应用于更复杂的 C++ 代码生成任务。
3. chapter 3： C++ 代码生成的核心 Prompt 策略
3.1 生成基本 C++ 语法结构
3.1.1 生成简单的 main 函数
main 函数是每个 C++ 可执行程序的入口点。使用 Prompt Engineering 可以快速生成包含基本结构的 main 函数。
示例 1：生成一个输出 "Hello, World!" 的 main 函数
Prompt： “请生成一个 C++ 的 main 函数，该函数在控制台输出 "Hello, World!"。”
生成的代码：
1
#include <iostream>
2
3
int main() {
4
std::cout << "Hello, World!" << std::endl;
5
return 0;
6
}
示例 2：生成一个带有命令行参数处理的 main 函数
Prompt： “请生成一个 C++ 的 main 函数，该函数接收命令行参数，并打印出参数的个数和每个参数的值。”
生成的代码：
1
#include <iostream>
2
#include <vector>
3
#include <string>
4
5
int main(int argc, char *argv[]) {
6
std::cout << "Number of arguments: " << argc << std::endl;
7
for (int i = 0; i < argc; ++i) {
8
std::cout << "Argument " << i << ": " << argv[i] << std::endl;
9
}
10
return 0;
11
}
3.1.2 生成头文件包含
在 C++ 中，使用 #include 指令来包含头文件，以便使用库提供的功能。Prompt Engineering 可以帮助我们生成必要的头文件包含。
示例 1：生成包含 iostream 和 vector 头文件的代码片段
Prompt： “请生成一个 C++ 代码片段，包含 <iostream> 和 <vector> 这两个头文件。”
生成的代码：
1
#include <iostream>
2
#include <vector>
示例 2：根据需求生成头文件包含
Prompt： “请生成一个 C++ 代码片段，该片段需要使用字符串处理和文件输入/输出功能，包含必要的头文件。”
生成的代码：
1
#include <iostream>
2
#include <fstream>
3
#include <string>
3.1.3 生成命名空间声明
使用命名空间可以避免命名冲突。using namespace std; 是一种常见的做法，但有时也建议使用更明确的命名空间引用。
示例 1：生成 using namespace std; 声明
Prompt： “请生成一个 C++ 代码片段，包含 using namespace std; 声明。”
生成的代码：
1
using namespace std;
示例 2：生成更明确的命名空间引用
Prompt： “请生成一个 C++ 代码片段，该片段需要在控制台输出信息，但不要使用 using namespace std;，而是明确引用 std 命名空间。”
生成的代码：
1
#include <iostream>
2
3
int main() {
4
std::cout << "Hello!" << std::endl;
5
return 0;
6
}
3.2 生成函数和类
3.2.1 生成简单函数
Prompt Engineering 可以用于生成各种类型的函数，从简单的数学运算到复杂的数据处理。
示例 1：生成一个计算两个浮点数平均值的函数
Prompt： “请生成一个 C++ 函数，名为 average，该函数接收两个 double 类型的参数，并返回它们的平均值（double 类型）。”
生成的代码：
1
double average(double num1, double num2) {
2
return (num1 + num2) / 2.0;
3
}
示例 2：生成一个判断字符串是否为空的函数
Prompt： “请生成一个 C++ 函数，名为 isEmpty，该函数接收一个 std::string 类型的参数，并返回一个 bool 值，指示该字符串是否为空。”
生成的代码：
1
#include <string>
2
3
bool isEmpty(const std::string& str) {
4
return str.empty();
5
}
3.2.2 生成带有注释的函数
为了提高代码的可读性，可以在 Prompt 中要求生成带有注释的函数。
示例： “请生成一个 C++ 函数，名为 power，该函数接收两个整数 base 和 exponent 作为输入，并返回 base 的 exponent 次方。请为该函数添加适当的注释。”
生成的代码：
1
#include <cmath> // 可以使用 cmath 库中的 pow 函数，或者手动实现
2
3
/**
4
* @brief 计算一个整数的指定次方。
5
*
6
* @param base 底数。
7
* @param exponent 指数。
8
* @return 底数的指数次方。
9
*/
10
int power(int base, int exponent) {
11
return std::pow(base, exponent);
12
}
或者，LLM 可能会选择手动实现：
1
/**
2
* @brief 计算一个整数的指定次方。
3
*
4
* @param base 底数。
5
* @param exponent 指数。
6
* @return 底数的指数次方。
7
*/
8
int power(int base, int exponent) {
9
int result = 1;
10
for (int i = 0; i < exponent; ++i) {
11
result *= base;
12
}
13
return result;
14
}
3.2.3 生成简单的类
Prompt Engineering 可以用于快速生成包含基本成员变量和成员函数的类。
示例 1：生成一个表示点的 Point 类
Prompt： “请生成一个 C++ 类，名为 Point，包含两个私有成员变量 x（整型）和 y（整型），以及一个公有的构造函数，用于初始化这两个成员变量，并提供公有的 Getter 方法 getX() 和 getY()。”
生成的代码：
1
class Point {
2
private:
3
int x;
4
int y;
5
6
public:
7
Point(int x_val, int y_val) : x(x_val), y(y_val) {}
8
9
int getX() const {
10
return x;
11
}
12
13
int getY() const {
14
return y;
15
}
16
};
示例 2：生成一个表示矩形的 Rectangle 类
Prompt： “请生成一个 C++ 类，名为 Rectangle，包含两个私有成员变量 width（双精度浮点型）和 height（双精度浮点型），以及以下公有成员函数：
- 一个构造函数，用于初始化 width 和 height。
- 一个 getArea() 方法，返回矩形的面积。
- 一个 getPerimeter() 方法，返回矩形的周长。”
生成的代码：
1
class Rectangle {
2
private:
3
double width;
4
double height;
5
6
public:
7
Rectangle(double w, double h) : width(w), height(h) {}
8
9
double getArea() const {
10
return width * height;
11
}
12
13
double getPerimeter() const {
14
return 2 * (width + height);
15
}
16
};
3.3 生成控制流语句
3.3.1 生成条件语句 (if, else if, else)
Prompt Engineering 可以用于生成根据条件执行不同代码块的控制流语句。
示例： “请生成一个 C++ 代码片段，该片段接收一个整数作为输入，如果该整数大于 0，则输出 "Positive"，如果小于 0，则输出 "Negative"，如果等于 0，则输出 "Zero"。”
生成的代码：
1
#include <iostream>
2
3
int main() {
4
int num;
5
std::cout << "Enter an integer: ";
6
std::cin >> num;
7
8
if (num > 0) {
9
std::cout << "Positive" << std::endl;
10
} else if (num < 0) {
11
std::cout << "Negative" << std::endl;
12
} else {
13
std::cout << "Zero" << std::endl;
14
}
15
16
return 0;
17
}
3.3.2 生成循环语句 (for, while, do-while)
Prompt Engineering 可以用于生成执行重复性任务的循环语句。
示例 1：生成一个使用 for 循环打印数字 1 到 10 的代码片段
Prompt： “请生成一个 C++ 代码片段，使用 for 循环打印数字 1 到 10。”
生成的代码：
1
#include <iostream>
2
3
int main() {
4
for (int i = 1; i <= 10; ++i) {
5
std::cout << i << " ";
6
}
7
std::cout << std::endl;
8
return 0;
9
}
示例 2：生成一个使用 while 循环读取用户输入直到输入 "exit" 的代码片段
Prompt： “请生成一个 C++ 代码片段，使用 while 循环不断读取用户的输入，直到用户输入 "exit"。每次读取到输入后，都将其打印出来。”
生成的代码：
1
#include <iostream>
2
#include <string>
3
4
int main() {
5
std::string input;
6
std::cout << "Enter text (type 'exit' to quit):" << std::endl;
7
while (std::cin >> input && input != "exit") {
8
std::cout << "You entered: " << input << std::endl;
9
std::cout << "Enter text (type 'exit' to quit):" << std::endl;
10
}
11
std::cout << "Exiting..." << std::endl;
12
return 0;
13
}
3.3.3 生成 switch 语句
Prompt Engineering 可以用于生成基于不同条件执行不同代码块的 switch 语句。
示例： “请生成一个 C++ 代码片段，该片段接收一个表示星期几的整数（1-7）作为输入，并使用 switch 语句打印出对应的星期几的名称。”
生成的代码：
1
#include <iostream>
2
3
int main() {
4
int day;
5
std::cout << "Enter a number (1-7) representing the day of the week: ";
6
std::cin >> day;
7
8
switch (day) {
9
case 1:
10
std::cout << "Monday" << std::endl;
11
break;
12
case 2:
13
std::cout << "Tuesday" << std::endl;
14
break;
15
case 3:
16
std::cout << "Wednesday" << std::endl;
17
break;
18
case 4:
19
std::cout << "Thursday" << std::endl;
20
break;
21
case 5:
22
std::cout << "Friday" << std::endl;
23
break;
24
case 6:
25
std::cout << "Saturday" << std::endl;
26
break;
27
case 7:
28
std::cout << "Sunday" << std::endl;
29
break;
30
default:
31
std::cout << "Invalid input." << std::endl;
32
break;
33
}
34
35
return 0;
36
}
3.4 生成数据结构
3.4.1 生成基本数据类型变量的声明和初始化
Prompt Engineering 可以用于生成基本数据类型（例如 int, double, bool, char）变量的声明和初始化。
示例： “请生成一个 C++ 代码片段，声明一个整型变量 age 并初始化为 30，一个双精度浮点型变量 pi 并初始化为 3.14159，以及一个布尔型变量 isValid 并初始化为 true。”
生成的代码：
1
int age = 30;
2
double pi = 3.14159;
3
bool isValid = true;
3.4.2 生成数组
Prompt Engineering 可以用于生成各种类型的数组。
示例： “请生成一个 C++ 代码片段，声明一个包含 5 个整数的数组，并使用一些初始值进行初始化。”
生成的代码：
1
int numbers[5] = {1, 2, 3, 4, 5};
3.4.3 生成 std::vector
std::vector 是 C++ 标准库中常用的动态数组。Prompt Engineering 可以用于生成 std::vector 的声明和初始化。
示例： “请生成一个 C++ 代码片段，声明一个存储字符串的 std::vector，并添加三个初始字符串元素：“apple”, “banana”, “cherry”。”
生成的代码：
1
#include <vector>
2
#include <string>
3
4
std::vector<std::string> fruits = {"apple", "banana", "cherry"};
3.4.4 生成 std::map
std::map 是 C++ 标准库中常用的关联容器，用于存储键值对。Prompt Engineering 可以用于生成 std::map 的声明和初始化。
示例： “请生成一个 C++ 代码片段，声明一个 std::map，用于存储学生的姓名（字符串）和对应的年龄（整数）。添加三个初始键值对：("Alice", 20), ("Bob", 22), ("Charlie", 21)。”
生成的代码：
1
#include <map>
2
#include <string>
3
4
std::map<std::string, int> studentAges = {
5
{"Alice", 20},
6
{"Bob", 22},
7
{"Charlie", 21}
8
};
3.5 生成算法实现
3.5.1 生成排序算法
Prompt Engineering 可以用于生成各种排序算法的实现，例如冒泡排序、选择排序、插入排序等。
示例： “请生成一个 C++ 函数，实现冒泡排序算法，对一个整数数组进行升序排序。”
生成的代码：
1
#include <vector>
2
#include <algorithm>
3
4
void bubbleSort(std::vector<int>& arr) {
5
int n = arr.size();
6
for (int i = 0; i < n - 1; ++i) {
7
for (int j = 0; j < n - i - 1; ++j) {
8
if (arr[j] > arr[j + 1]) {
9
std::swap(arr[j], arr[j + 1]);
10
}
11
}
12
}
13
}
3.5.2 生成搜索算法
Prompt Engineering 可以用于生成各种搜索算法的实现，例如线性搜索、二分搜索等。
示例： “请生成一个 C++ 函数，实现二分搜索算法，在一个已排序的整数数组中查找指定的元素，并返回其索引。如果元素不存在，则返回 -1。”
生成的代码：
1
#include <vector>
2
3
int binarySearch(const std::vector<int>& arr, int target) {
4
int left = 0;
5
int right = arr.size() - 1;
6
7
while (left <= right) {
8
int mid = left + (right - left) / 2;
9
if (arr[mid] == target) {
10
return mid;
11
} else if (arr[mid] < target) {
12
left = mid + 1;
13
} else {
14
right = mid - 1;
15
}
16
}
17
return -1;
18
}
3.5.3 生成字符串处理算法
Prompt Engineering 可以用于生成各种字符串处理算法的实现，例如字符串反转、查找子串等。
示例： “请生成一个 C++ 函数，该函数接收一个字符串作为输入，并返回其反转后的字符串。”
生成的代码：
1
#include <string>
2
#include <algorithm>
3
4
std::string reverseString(const std::string& str) {
5
std::string reversed_str = str;
6
std::reverse(reversed_str.begin(), reversed_str.end());
7
return reversed_str;
8
}
本章介绍了使用 Prompt Engineering 生成基本 C++ 语法结构、函数、类、控制流语句、数据结构和算法的核心策略。通过清晰地表达指令、提供必要的上下文信息以及指定输出格式，我们可以有效地利用 LLMs 快速生成所需的 C++ 代码片段。在接下来的章节中，我们将探讨如何将这些基础策略应用于更具体的任务和更高级的场景。
4. chapter 4： 面向特定任务的 C++ 代码生成实例
4.1 生成文件操作代码
4.1.1 读取文本文件内容
Prompt Engineering 可以用于生成读取文本文件内容的代码。
示例： “请生成一个 C++ 函数，该函数接收一个文件路径作为输入，读取该文本文件的所有内容，并将内容作为一个字符串返回。如果文件不存在或无法打开，则返回一个空字符串。”
生成的代码：
1
#include <iostream>
2
#include <fstream>
3
#include <string>
4
#include <sstream>
5
6
std::string readFileContent(const std::string& filePath) {
7
std::ifstream inputFile(filePath);
8
if (!inputFile.is_open()) {
9
std::cerr << "Error opening file: " << filePath << std::endl;
10
return "";
11
}
12
std::stringstream buffer;
13
buffer << inputFile.rdbuf();
14
inputFile.close();
15
return buffer.str();
16
}
应用个例： 假设你需要读取一个配置文件（例如 .ini 或 .txt 格式），可以使用此函数将文件内容读取到字符串中，然后进行解析。
4.1.2 写入文本内容到文件
Prompt Engineering 可以用于生成将文本内容写入文件的代码.
示例： “请生成一个 C++ 函数，该函数接收一个文件路径和一个字符串作为输入，将该字符串的内容写入到指定的文件中。如果文件无法打开或写入失败，则返回 false，否则返回 true。”
生成的代码：
1
#include <iostream>
2
#include <fstream>
3
#include <string>
4
5
bool writeFileContent(const std::string& filePath, const std::string& content) {
6
std::ofstream outputFile(filePath);
7
if (!outputFile.is_open()) {
8
std::cerr << "Error opening file for writing: " << filePath << std::endl;
9
return false;
10
}
11
outputFile << content;
12
outputFile.close();
13
return true;
14
}
应用个例： 你可以使用此函数将程序的运行日志、生成的报告或其他需要持久化存储的数据写入到文件中。
4.1.3 检查文件是否存在
Prompt Engineering 可以用于生成检查文件是否存在代码。
示例： “请生成一个 C++ 函数，该函数接收一个文件路径作为输入，并返回一个布尔值，指示该文件是否存在。”
生成的代码：
1
#include <fstream>
2
3
bool isFileExists(const std::string& filePath) {
4
std::ifstream f(filePath.c_str());
5
return f.good();
6
}
应用个例： 在进行文件操作之前，可以使用此函数检查文件是否存在，避免因文件不存在而导致的错误。
4.2 生成字符串处理代码
4.2.1 字符串分割
Prompt Engineering 可以用于生成将字符串按照指定分隔符分割成多个子字符串的代码。
示例： “请生成一个 C++ 函数，该函数接收一个字符串和一个分隔符字符作为输入，将该字符串按照分隔符分割成多个子字符串，并将这些子字符串存储在一个 std::vector<std::string> 中返回。”
生成的代码：
1
#include <iostream>
2
#include <string>
3
#include <vector>
4
#include <sstream>
5
6
std::vector<std::string> splitString(const std::string& str, char delimiter) {
7
std::vector<std::string> tokens;
8
std::string token;
9
std::istringstream tokenStream(str);
10
while (std::getline(tokenStream, token, delimiter)) {
11
tokens.push_back(token);
12
}
13
return tokens;
14
}
应用个例： 你可以使用此函数解析 CSV 文件中的每一行数据，或解析以特定分隔符分隔的命令行参数。
4.2.2 字符串替换
Prompt Engineering 可以用于生成将字符串中的某个子串替换为另一个子串的代码.
示例： “请生成一个 C++ 函数，该函数接收一个字符串、一个要被替换的子串和一个新的子串作为输入，将原字符串中所有出现的要被替换的子串替换为新的子串，并返回替换后的字符串。”
生成的代码：
1
#include <iostream>
2
#include <string>
3
4
std::string replaceString(std::string str, const std::string& from, const std::string& to) {
5
size_t start_pos = 0;
6
while ((start_pos = str.find(from, start_pos)) != std::string::npos) {
7
str.replace(start_pos, from.length(), to);
8
start_pos += to.length(); // In case 'to' is a substring of 'from'
9
}
10
return str;
11
}
应用个例： 你可以使用此函数替换文本文件中的特定关键词，或修改用户输入的字符串。
4.2.3 字符串转换为整数
Prompt Engineering 可以用于生成将字符串转换为整数的代码，并进行错误处理。
示例： “请生成一个 C++ 函数，该函数接收一个字符串作为输入，尝试将其转换为一个整数。如果转换成功，则返回该整数；如果转换失败（例如，字符串包含非数字字符），则抛出一个 std::invalid_argument 异常。”
生成的代码：
1
#include <iostream>
2
#include <string>
3
#include <stdexcept>
4
5
int stringToInt(const std::string& str) {
6
try {
7
return std::stoi(str);
8
} catch (const std::invalid_argument& e) {
9
throw std::invalid_argument("Invalid argument: cannot convert '" + str + "' to integer.");
10
} catch (const std::out_of_range& e) {
11
throw std::out_of_range("Out of range: integer value of '" + str + "' is too large or too small.");
12
}
13
}
应用个例： 当需要从用户输入或配置文件中读取数字时，可以使用此函数进行转换，并捕获可能的错误。
4.3 生成网络编程相关代码
4.3.1 简单的 TCP 客户端
Prompt Engineering 可以用于生成一个简单的 TCP 客户端代码，用于连接到服务器并发送数据。
示例： “请生成一个简单的 C++ TCP 客户端代码，该客户端连接到 IP 地址 127.0.0.1 和端口号 12345，并发送字符串 "Hello, Server!"，然后接收服务器的响应并打印出来。可以使用 <sys/socket.h> 和 <netinet/in.h> 等 POSIX 网络编程接口。”
生成的代码：
1
#include <iostream>
2
#include <string>
3
#include <cstring>
4
#include <unistd.h>
5
#include <arpa/inet.h>
6
#include <sys/socket.h>
7
#include <netinet/in.h>
8
9
int main() {
10
int clientSocket;
11
struct sockaddr_in serverAddr;
12
char buffer[1024] = {0};
13
const char* message = "Hello, Server!";
14
int valread;
15
16
// 创建 socket 文件描述符
17
if ((clientSocket = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
18
std::cerr << "Socket creation error" << std::endl;
19
return -1;
20
}
21
22
serverAddr.sin_family = AF_INET;
23
serverAddr.sin_port = htons(12345);
24
25
// 将 IPv4 或 IPv6 地址从文本转换为二进制形式
26
if (inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr) <= 0) {
27
std::cerr << "Invalid address/ Address not supported" << std::endl;
28
close(clientSocket);
29
return -1;
30
}
31
32
// 连接到服务器
33
if (connect(clientSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
34
std::cerr << "Connection failed" << std::endl;
35
close(clientSocket);
36
return -1;
37
}
38
39
// 发送消息到服务器
40
send(clientSocket, message, strlen(message), 0);
41
std::cout << "Message sent to server" << std::endl;
42
43
// 接收服务器的响应
44
valread = read(clientSocket, buffer, 1024);
45
std::cout << "Response from server: " << buffer << std::endl;
46
47
// 关闭 socket
48
close(clientSocket);
49
return 0;
50
}
应用个例： 可以作为与其他网络服务进行交互的基础代码。
4.3.2 简单的 TCP 服务器
Prompt Engineering 可以用于生成一个简单的 TCP 服务器代码，用于监听指定端口并响应客户端的请求。
示例： “请生成一个简单的 C++ TCP 服务器代码，该服务器监听端口号 12345，当接收到客户端的连接后，接收客户端发送的消息，并在控制台打印出来，然后向客户端发送响应消息 "Message received!"。可以使用 <sys/socket.h> 和 <netinet/in.h> 等 POSIX 网络编程接口。”
生成的代码：
1
#include <iostream>
2
#include <string>
3
#include <cstring>
4
#include <unistd.h>
5
#include <arpa/inet.h>
6
#include <sys/socket.h>
7
#include <netinet/in.h>
8
9
int main() {
10
int server_fd, new_socket;
11
struct sockaddr_in address;
12
int opt = 1;
13
socklen_t addrlen = sizeof(address);
14
char buffer[1024] = {0};
15
const char* response = "Message received!";
16
17
// 创建 socket 文件描述符
18
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
19
std::cerr << "Socket creation failed" << std::endl;
20
return -1;
21
}
22
23
// 强制将 socket 绑定到端口和 IP 地址
24
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
25
std::cerr << "setsockopt failed" << std::endl;
26
close(server_fd);
27
return -1;
28
}
29
address.sin_family = AF_INET;
30
address.sin_addr.s_addr = INADDR_ANY;
31
address.sin_port = htons(12345);
32
33
// 将 socket 绑定到指定的端口
34
if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
35
std::cerr << "bind failed" << std::endl;
36
close(server_fd);
37
return -1;
38
}
39
40
// 开始监听连接
41
if (listen(server_fd, 3) < 0) {
42
std::cerr << "listen failed" << std::endl;
43
close(server_fd);
44
return -1;
45
}
46
std::cout << "Server listening on port 12345..." << std::endl;
47
48
// 接受连接
49
if ((new_socket = accept(server_fd, (struct sockaddr*)&address, &addrlen)) < 0) {
50
std::cerr << "accept failed" << std::endl;
51
close(server_fd);
52
return -1;
53
}
54
55
// 读取客户端发送的消息
56
int valread = read(new_socket, buffer, 1024);
57
std::cout << "Message from client: " << buffer << std::endl;
58
59
// 向客户端发送响应
60
send(new_socket, response, strlen(response), 0);
61
std::cout << "Response sent to client" << std::endl;
62
63
// 关闭 socket
64
close(new_socket);
65
close(server_fd);
66
return 0;
67
}
应用个例： 可以作为构建简单网络应用程序的基础。
4.4 生成数据库操作代码
4.4.1 连接到 SQLite 数据库并执行查询
Prompt Engineering 可以用于生成连接到 SQLite 数据库并执行 SQL 查询的代码。
示例： “请生成 C++ 代码，使用 SQLite 库连接到名为 mydatabase.db 的数据库，并执行一个查询 SELECT name, age FROM users;，然后打印出查询结果。你需要包含必要的头文件，并进行错误处理。”
生成的代码（需要安装 SQLite 库）：
1
#include <iostream>
2
#include <sqlite3.h>
3
4
int main() {
5
sqlite3* db;
6
int rc;
7
8
// 打开数据库
9
rc = sqlite3_open("mydatabase.db", &db);
10
if (rc) {
11
std::cerr << "Can't open database: " << sqlite3_errmsg(db) << std::endl;
12
return 1;
13
} else {
14
std::cout << "Opened database successfully" << std::endl;
15
}
16
17
// 执行 SQL 查询
18
const char* sql = "SELECT name, age FROM users;";
19
sqlite3_stmt* stmt;
20
21
rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);
22
if (rc != SQLITE_OK) {
23
std::cerr << "SQL error: " << sqlite3_errmsg(db) << std::endl;
24
sqlite3_finalize(stmt);
25
sqlite3_close(db);
26
return 1;
27
}
28
29
// 遍历查询结果
30
std::cout << "Query results:" << std::endl;
31
while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
32
std::cout << "Name: " << sqlite3_column_text(stmt, 0)
33
<< ", Age: " << sqlite3_column_int(stmt, 1) << std::endl;
34
}
35
36
// 释放资源
37
sqlite3_finalize(stmt);
38
sqlite3_close(db);
39
return 0;
40
}
应用个例： 可以用于读取和操作本地 SQLite 数据库中的数据。
4.4.2 向 SQLite 数据库插入数据
Prompt Engineering 可以用于生成向 SQLite 数据库插入数据的代码。
示例： “请生成 C++ 代码，使用 SQLite 库连接到名为 mydatabase.db 的数据库，并执行一个插入操作，向 users 表中插入一条新的记录，包含 name 为 'John Doe'，age 为 30。你需要包含必要的头文件，并进行错误处理。”
生成的代码（需要安装 SQLite 库）：
1
#include <iostream>
2
#include <sqlite3.h>
3
#include <string>
4
5
int main() {
6
sqlite3* db;
7
int rc;
8
const char* data_name = "John Doe";
9
int data_age = 30;
10
11
// 打开数据库
12
rc = sqlite3_open("mydatabase.db", &db);
13
if (rc) {
14
std::cerr << "Can't open database: " << sqlite3_errmsg(db) << std::endl;
15
return 1;
16
} else {
17
std::cout << "Opened database successfully" << std::endl;
18
}
19
20
// 构建 SQL 插入语句
21
std::string sql = "INSERT INTO users (name, age) VALUES('" + std::string(data_name) + "', " + std::to_string(data_age) + ");";
22
char* errmsg = 0;
23
24
// 执行 SQL 插入操作
25
rc = sqlite3_exec(db, sql.c_str(), 0, 0, &errmsg);
26
if (rc != SQLITE_OK) {
27
std::cerr << "SQL error: " << errmsg << std::endl;
28
sqlite3_free(errmsg);
29
} else {
30
std::cout << "Record inserted successfully" << std::endl;
31
}
32
33
// 关闭数据库
34
sqlite3_close(db);
35
return 0;
36
}
应用个例： 可以用于向本地 SQLite 数据库中添加新的数据记录。
4.5 生成简单的游戏逻辑
4.5.1 实现一个简单的猜数字游戏
Prompt Engineering 可以用于生成一个简单的命令行猜数字游戏的代码。
示例： “请生成一个简单的 C++ 命令行猜数字游戏代码。程序应该随机生成一个 1 到 100 之间的整数，然后提示用户输入猜测的数字。如果用户猜对了，程序应该输出 "Congratulations! You guessed the number." 并结束。如果用户猜错了，程序应该提示用户猜的数字是大了还是小了，并允许用户继续猜测，直到猜对为止。”
生成的代码：
1
#include <iostream>
2
#include <cstdlib>
3
#include <ctime>
4
5
int main() {
6
// 设置随机数种子
7
std::srand(std::time(0));
8
int secretNumber = std::rand() % 100 + 1;
9
int guess;
10
int attempts = 0;
11
12
std::cout << "Welcome to the Guess the Number game!" << std::endl;
13
std::cout << "I'm thinking of a number between 1 and 100." << std::endl;
14
15
do {
16
std::cout << "Enter your guess: ";
17
std::cin >> guess;
18
attempts++;
19
20
if (guess > secretNumber) {
21
std::cout << "Too high! Try again." << std::endl;
22
} else if (guess < secretNumber) {
23
std::cout << "Too low! Try again." << std::endl;
24
} else {
25
std::cout << "Congratulations! You guessed the number " << secretNumber << " in " << attempts << " attempts." << std::endl;
26
}
27
} while (guess != secretNumber);
28
29
return 0;
30
}
应用个例： 可以作为学习 C++ 基础语法和控制流的简单示例。
4.5.2 实现一个简单的命令行计算器
Prompt Engineering 可以用于生成一个简单的命令行计算器代码，支持基本的加减乘除运算。
示例： “请生成一个简单的 C++ 命令行计算器代码。程序应该提示用户输入两个数字和一个运算符（+、-、*、/），然后根据用户输入执行相应的运算，并输出结果。”
生成的代码：
1
#include <iostream>
2
3
int main() {
4
double num1, num2;
5
char operation;
6
7
std::cout << "Enter first number: ";
8
std::cin >> num1;
9
10
std::cout << "Enter an operator (+, -, *, /): ";
11
std::cin >> operation;
12
13
std::cout << "Enter second number: ";
14
std::cin >> num2;
15
16
double result;
17
18
switch (operation) {
19
case '+':
20
result = num1 + num2;
21
break;
22
case '-':
23
result = num1 - num2;
24
break;
25
case '*':
26
result = num1 * num2;
27
break;
28
case '/':
29
if (num2 != 0) {
30
result = num1 / num2;
31
} else {
32
std::cout << "Error: Division by zero!" << std::endl;
33
return 1;
34
}
35
break;
36
default:
37
std::cout << "Error: Invalid operator!" << std::endl;
38
return 1;
39
}
40
41
std::cout << "Result: " << num1 << " " << operation << " " << num2 << " = " << result << std::endl;
42
43
return 0;
44
}
应用个例： 可以作为学习 C++ 输入输出和 switch 语句的简单示例。
本章通过丰富的实例展示了如何使用 Prompt Engineering 生成面向特定任务的 C++ 代码。这些例子涵盖了文件操作、字符串处理、网络编程、数据库操作以及简单的游戏逻辑。读者可以借鉴这些示例，根据自己的实际需求，设计出能够生成实用 C++ 代码的 Prompt。在下一章，我们将探讨更高级的 Prompt Engineering 技巧和应用。
5. chapter 5： 高级 Prompt Engineering 技巧与应用
5.1 使用 Few-Shot Prompting 进行复杂代码生成
5.1.1 什么是 Few-Shot Prompting？
Few-Shot Prompting 是一种高级的 Prompt Engineering 技术，它通过在 Prompt 中提供少量的输入-输出示例（in-context learning），来引导 LLM 生成更复杂、更符合特定要求的输出。与 Zero-Shot Prompting（不提供任何示例）和 One-Shot Prompting（提供一个示例）相比，Few-Shot Prompting 可以让模型更好地理解任务的细微差别和期望的模式。
5.1.2 Few-Shot Prompting 的优势
① 处理复杂任务：对于那些难以用简单的指令描述清楚的任务，提供几个示例可以帮助模型更好地理解任务的目标和约束。
② 学习特定风格和格式：通过示例，模型可以学习到特定的编码风格、命名约定或输出格式，从而生成更符合项目要求的代码。
③ 减少歧义：示例可以消除指令中的歧义，让模型更准确地理解用户的意图。
5.1.3 如何构建 Few-Shot Prompt
一个典型的 Few-Shot Prompt 包含以下结构：
1
<示例 1 - 输入> -> <示例 1 - 输出>
2
<示例 2 - 输入> -> <示例 2 - 输出>
3
...
4
<示例 N - 输入> -> <期望的输入>
其中，<示例 i - 输入> 是任务的输入，<示例 i - 输出> 是对应输入的期望输出。最后一行是我们需要模型处理的实际输入。
5.1.4 C++ 代码生成中的 Few-Shot Prompting 示例
示例： 假设我们需要生成一个函数，该函数根据输入的字符串判断其是否为回文串，并且我们希望生成的函数包含详细的注释。
Few-Shot Prompt：
1
输入: "madam" -> 输出:
2
/**
3
* @brief 判断一个字符串是否为回文串。
4
*
5
* @param str 输入字符串。
6
* @return 如果是回文串则返回 true，否则返回 false。
7
*/
8
bool isPalindrome(const std::string& str) {
9
std::string reversed_str = str;
10
std::reverse(reversed_str.begin(), reversed_str.end());
11
return str == reversed_str;
12
}
13
14
输入: "racecar" -> 输出:
15
/**
16
* @brief 判断一个字符串是否为回文串。
17
*
18
* @param str 输入字符串。
19
* @return 如果是回文串则返回 true，否则返回 false。
20
*/
21
bool isPalindrome(const std::string& str) {
22
int left = 0;
23
int right = str.length() - 1;
24
while (left < right) {
25
if (str[left] != str[right]) {
26
return false;
27
}
28
left++;
29
right--;
30
}
31
return true;
32
}
33
34
输入: "hello" -> 输出:
期望的输出：
1
/**
2
* @brief 判断一个字符串是否为回文串。
3
*
4
* @param str 输入字符串。
5
* @return 如果是回文串则返回 true，否则返回 false。
6
*/
7
bool isPalindrome(const std::string& str) {
8
int left = 0;
9
int right = str.length() - 1;
10
while (left < right) {
11
if (str[left] != str[right]) {
12
return false;
13
}
14
left++;
15
right--;
16
}
17
return true;
18
}
分析： 在这个示例中，我们提供了两个回文串的示例，并展示了期望的带有注释的 isPalindrome 函数。当模型看到 "hello" 这个输入时，它应该能够理解任务是判断字符串是否为回文串，并生成相应的 C++ 函数，而且很可能会遵循示例中的注释风格。
5.1.5 注意事项
① 示例质量：提供的示例应该具有代表性，能够覆盖任务的各种情况和边界条件。
② 示例数量：通常不需要太多的示例，少量的精心挑选的示例往往比大量的随意示例更有效。
③ 输入-输出格式一致性：示例中的输入和输出格式应该与实际需要处理的输入和期望的输出格式保持一致。
5.2 利用思维链（Chain of Thought）进行问题分解与代码生成
5.2.1 什么是思维链？
思维链（Chain of Thought, CoT）是一种 Prompt Engineering 技术，它通过引导 LLM 逐步思考并解释其解决问题的过程，来提高模型在复杂推理任务中的表现。在代码生成领域，思维链可以帮助模型将一个复杂的问题分解为一系列更小的、更易于处理的子问题，然后逐步生成相应的代码。
5.2.2 思维链的优势
① 解决复杂问题：对于需要多步骤推理才能解决的问题，思维链可以帮助模型更好地组织思路，逐步生成正确的代码。
② 提高可解释性：通过模型的思考过程，我们可以更好地理解模型是如何生成代码的，从而更容易发现和纠正错误。
③ 引导模型学习：思维链可以作为一种隐式的监督信号，引导模型学习如何进行问题分解和逐步求解。
5.2.3 如何构建思维链 Prompt
一个典型的思维链 Prompt 包含以下结构：
1
问题：<需要解决的问题>
2
3
思考过程：
4
首先，<步骤 1 的思考>
5
然后，<步骤 2 的思考>
6
...
7
最后，<最终步骤的思考>
8
9
代码：
5.2.4 C++ 代码生成中的思维链示例
示例： 假设我们需要生成一个函数，该函数接收一个整数数组作为输入，并返回数组中第二大的元素。
思维链 Prompt：
1
问题：请生成一个 C++ 函数，该函数接收一个整数数组作为输入，并返回数组中第二大的元素。如果数组的元素个数少于 2 个，则返回 -1。
2
3
思考过程：
4
首先，我们需要检查数组的元素个数是否小于 2。如果是，则直接返回 -1。
5
然后，我们需要找到数组中最大的元素。
6
接着，我们需要将最大的元素从数组中移除或者在查找过程中忽略它。
7
最后，我们需要在剩余的元素中找到最大的元素，这个元素就是原数组中第二大的元素。
8
9
代码：
生成的代码：
1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4
#include <limits>
5
6
int findSecondLargest(const std::vector<int>& nums) {
7
if (nums.size() < 2) {
8
return -1;
9
}
10
11
int largest = std::numeric_limits<int>::min();
12
int secondLargest = std::numeric_limits<int>::min();
13
14
for (int num : nums) {
15
if (num > largest) {
16
secondLargest = largest;
17
largest = num;
18
} else if (num > secondLargest && num != largest) {
19
secondLargest = num;
20
}
21
}
22
23
if (secondLargest == std::numeric_limits<int>::min()) {
24
// 如果所有元素都相同，则返回 -1，或者根据具体需求处理
25
return -1;
26
}
27
28
return secondLargest;
29
}
分析： 在这个示例中，我们通过“思考过程”部分引导模型逐步分析了解决问题的步骤。模型根据这些步骤生成了相应的 C++ 代码。可以看到，生成的代码逻辑清晰，考虑了数组元素个数小于 2 的情况，并且通过遍历数组找到了第二大的元素。
5.2.5 注意事项
① 思考过程的清晰度：思考过程应该清晰、简洁、逻辑连贯，能够准确地反映解决问题的步骤。
② 逐步引导：对于更复杂的问题，可以将思考过程分解为更小的步骤，逐步引导模型生成代码。
③ 与 Few-Shot Prompting 结合使用：可以将思维链与 Few-Shot Prompting 结合使用，提供一些带有思考过程的示例，帮助模型更好地理解如何进行问题分解和代码生成。
5.3 集成外部知识与 API 文档
5.3.1 利用 Prompt 引导模型查询外部知识
有时，我们需要生成的 C++ 代码涉及到特定的库、框架或 API。Prompt Engineering 可以引导 LLM 查询相关的外部知识或 API 文档，从而生成更准确、更符合要求的代码。
5.3.2 如何在 Prompt 中集成外部知识
① 提供相关的库或 API 名称：在 Prompt 中明确提及需要使用的库或 API 的名称，例如 “使用 OpenCV 库”、“使用 Boost.Asio 库”、“参考 std::filesystem API” 等。
示例： “请生成一个 C++ 函数，使用 OpenCV 库读取一张图片并将其转换为灰度图。”
② 提供关键的函数或类名：如果知道需要使用的具体函数或类名，可以在 Prompt 中直接提及。
示例： “请生成一个 C++ 代码片段，使用 std::chrono::system_clock::now() 获取当前时间。”
③ 描述期望的功能，让模型自行选择合适的库或 API：可以更抽象地描述期望的功能，让 LLM 根据其知识库选择合适的库或 API。
示例： “请生成一个 C++ 函数，用于发送 HTTP GET 请求并获取响应内容。”
5.3.3 示例：使用 Boost.Asio 进行异步网络操作
Prompt： “请生成一个 C++ 代码片段，使用 Boost.Asio 库实现一个异步的 TCP 客户端，连接到 127.0.0.1:8080 并发送字符串 "Hello"。当接收到服务器的响应后，将响应打印到控制台。”
生成的代码（可能需要用户安装 Boost 库）：
1
#include <iostream>
2
#include <boost/asio.hpp>
3
4
using boost::asio::ip::tcp;
5
6
int main() {
7
try {
8
boost::asio::io_context io_context;
9
tcp::socket socket(io_context);
10
tcp::endpoint endpoint(boost::asio::ip::address::from_string("127.0.0.1"), 8080);
11
socket.connect(endpoint);
12
13
std::string message = "Hello\n";
14
boost::asio::write(socket, boost::asio::buffer(message));
15
std::cout << "Sent: " << message;
16
17
boost::asio::streambuf response;
18
boost::asio::read_until(socket, response, '\n');
19
std::istream response_stream(&response);
20
std::string line;
21
std::getline(response_stream, line);
22
std::cout << "Received: " << line << std::endl;
23
} catch (std::exception& e) {
24
std::cerr << "Exception: " << e.what() << std::endl;
25
}
26
27
return 0;
28
}
分析： 模型识别出需要进行异步网络操作，并选择了 Boost.Asio 库来实现。它使用了 boost::asio::io_context、tcp::socket、tcp::endpoint 等相关的类和函数，实现了连接、发送和接收数据的过程。
5.3.4 注意事项
① 模型知识的局限性：LLMs 的知识库可能不是最新的，或者可能对某些特定的库或 API 的细节了解不够深入。
② 需要用户安装和配置外部库：如果生成的代码使用了第三方库，用户需要确保已经安装并正确配置了这些库。
③ 验证生成代码的正确性：对于涉及到外部知识的代码，务必进行测试和验证，确保其功能和正确性。
5.4 处理代码生成中的错误与异常
5.4.1 引导模型生成错误处理代码
在实际的 C++ 编程中，错误处理是非常重要的。Prompt Engineering 可以引导 LLM 生成包含错误处理机制的代码，例如使用 try-catch 块、检查返回值等。
5.4.2 如何引导模型生成错误处理代码
① 明确要求包含错误处理：在 Prompt 中明确指出需要包含错误处理逻辑。
示例： “请生成一个 C++ 函数，该函数打开一个指定路径的文件进行读取。如果文件不存在或无法打开，请包含适当的错误处理代码，例如输出错误信息到 std::cerr 并返回一个错误码。”
② 指定需要处理的特定错误类型：可以更具体地指定需要处理的错误类型，例如文件 I/O 异常、网络连接错误等。
示例： “请生成一个 C++ 函数，该函数尝试连接到指定的服务器。如果连接超时，请捕获相应的异常并输出错误信息。”
③ 提供错误处理的示例：可以使用 Few-Shot Prompting 提供一些包含错误处理的代码示例，引导模型学习如何处理错误。
5.4.3 示例：生成带有文件打开错误处理的函数
Prompt： “请生成一个 C++ 函数，该函数接收一个文件路径作为输入，尝试打开该文件进行读取。如果文件无法打开，函数应该返回 nullptr；否则，返回指向 std::ifstream 对象的指针。”
生成的代码：
1
#include <iostream>
2
#include <fstream>
3
4
std::ifstream* openFileForReading(const std::string& filePath) {
5
std::ifstream* inputFile = new std::ifstream(filePath);
6
if (!inputFile->is_open()) {
7
std::cerr << "Error opening file: " << filePath << std::endl;
8
delete inputFile;
9
return nullptr;
10
}
11
return inputFile;
12
}
分析： 模型在生成的代码中检查了文件是否成功打开，如果打开失败，则输出了错误信息并返回了 nullptr，从而实现了基本的错误处理。
5.4.4 引导模型处理异常
Prompt： “请生成一个 C++ 函数，该函数接收两个整数作为输入，并返回它们的商。如果除数为零，请抛出一个 std::invalid_argument 异常。”
生成的代码：
1
#include <iostream>
2
#include <stdexcept>
3
4
double divide(int numerator, int denominator) {
5
if (denominator == 0) {
6
throw std::invalid_argument("Error: Division by zero!");
7
}
8
return static_cast<double>(numerator) / denominator;
9
}
应用个例： 在需要进行除法运算的场景中，可以使用此函数来避免除以零导致的程序崩溃。调用此函数的代码可以使用 try-catch 块来捕获并处理 std::invalid_argument 异常。
5.4.5 注意事项
① 错误处理的完整性：LLM 生成的错误处理代码可能并不总是完整或最优的，需要开发者进行审查和完善。
② 特定于应用场景的错误处理：某些错误处理逻辑可能非常依赖于具体的应用场景，需要在 Prompt 中提供更详细的上下文信息。
5.5 生成符合特定编码规范的代码
5.5.1 引导模型遵循编码规范
在团队协作开发中，遵循统一的编码规范非常重要，可以提高代码的可读性和可维护性。Prompt Engineering 可以引导 LLM 生成符合特定编码规范的代码。
5.5.2 如何引导模型遵循编码规范
① 明确指定编码规范：在 Prompt 中明确提及需要遵循的编码规范，例如 “请遵循 Google C++ Style Guide”、“请遵循 MISRA C++ 规范” 等。
示例： “请生成一个 C++ 函数，计算两个整数的和，并遵循 Google C++ Style Guide 的命名约定和格式。”
② 提供编码规范的示例：可以使用 Few-Shot Prompting 提供一些符合特定编码规范的代码示例，引导模型学习这些规范。
③ 指定具体的编码规则：可以更具体地指定需要遵循的编码规则，例如命名约定、缩进风格、注释格式等。
示例： “请生成一个 C++ 类，类名使用驼峰命名法（CamelCase），成员变量使用下划线命名法（snake_case），方法名使用驼峰命名法，并添加 Doxygen 风格的注释。”
5.5.3 示例：生成符合 Google C++ Style Guide 的代码
Prompt： “请生成一个 C++ 函数，名为 CalculateSum，该函数接收两个整数作为输入，并返回它们的和。请遵循 Google C++ Style Guide。”
生成的代码（可能符合 Google C++ Style Guide 的风格）：
1
#include <iostream>
2
3
namespace { // Unnamed namespace for internal linkage
4
5
// Calculates the sum of two integers.
6
int CalculateSum(int a, int b) {
7
return a + b;
8
}
9
10
} // namespace
11
12
int main() {
13
int num1 = 5;
14
int num2 = 10;
15
int sum = CalculateSum(num1, num2);
16
std::cout << "The sum is: " << sum << std::endl;
17
return 0;
18
}
分析： 模型在生成的代码中使用了驼峰命名法作为函数名，并包含了简明的注释。虽然这只是一个简单的示例，但在更复杂的场景下，通过明确指定编码规范，可以引导模型生成更符合要求的代码。
5.5.4 注意事项
① 模型对编码规范的理解程度：LLMs 对不同编码规范的理解程度可能有所不同，生成的代码可能并不完全符合规范。
② 需要人工审查：即使引导模型遵循编码规范，仍然需要进行人工审查，确保生成的代码符合要求。
本章介绍了 Prompt Engineering 的一些高级技巧和应用，包括使用 Few-Shot Prompting 进行复杂代码生成、利用思维链进行问题分解、集成外部知识与 API 文档、处理代码生成中的错误与异常以及生成符合特定编码规范的代码。掌握这些高级技巧可以帮助我们更有效地利用 LLMs 生成高质量的 C++ 代码，并解决更复杂的编程问题。在下一章，我们将通过一些实战案例分析，进一步展示这些技巧的应用和价值。
6. chapter 6： 实战案例分析与启发
6.1 案例一：快速生成简单的命令行工具
6.1.1 需求描述
我们需要一个简单的命令行工具，该工具能够接收一个文本文件作为输入，统计文件中每个单词出现的次数，并将结果按照出现次数降序排列后输出到控制台。
6.1.2 使用 Prompt Engineering 生成代码
Prompt： “请生成一个 C++ 命令行工具的代码，该工具接收一个文本文件路径作为命令行参数。程序应该读取该文件的内容，统计每个单词出现的次数（忽略大小写和标点符号），并将结果按照单词出现次数从高到低排序后输出到控制台，每行输出一个单词及其出现次数，格式为 "单词: 次数"。请包含必要的头文件和错误处理。”
6.1.3 生成的代码
1
#include <iostream>
2
#include <fstream>
3
#include <sstream>
4
#include <string>
5
#include <map>
6
#include <vector>
7
#include <algorithm>
8
#include <cctype>
9
10
// 辅助函数：将字符串转换为小写
11
std::string toLower(const std::string& str) {
12
std::string result = "";
13
for (char c : str) {
14
result += std::tolower(c);
15
}
16
return result;
17
}
18
19
// 辅助函数：移除字符串中的标点符号
20
std::string removePunctuation(const std::string& str) {
21
std::string result = "";
22
for (char c : str) {
23
if (!std::ispunct(c)) {
24
result += c;
25
}
26
}
27
return result;
28
}
29
30
int main(int argc, char *argv[]) {
31
if (argc != 2) {
32
std::cerr << "Usage: " << argv[0] << " <input_file>" << std::endl;
33
return 1;
34
}
35
36
std::string filePath = argv[1];
37
std::ifstream inputFile(filePath);
38
39
if (!inputFile.is_open()) {
40
std::cerr << "Error opening file: " << filePath << std::endl;
41
return 1;
42
}
43
44
std::map<std::string, int> wordCounts;
45
std::string line;
46
47
while (std::getline(inputFile, line)) {
48
std::stringstream ss(line);
49
std::string word;
50
while (ss >> word) {
51
word = removePunctuation(word);
52
word = toLower(word);
53
if (!word.empty()) {
54
wordCounts[word]++;
55
}
56
}
57
}
58
59
inputFile.close();
60
61
// 将 map 转换为 vector 以进行排序
62
std::vector<std::pair<std::string, int>> sortedWordCounts(wordCounts.begin(), wordCounts.end());
63
64
// 按照出现次数降序排序
65
std::sort(sortedWordCounts.begin(), sortedWordCounts.end(),
66
[](const std::pair<std::string, int>& a, const std::pair<std::string, int>& b) {
67
return a.second > b.second;
68
});
69
70
// 输出结果
71
for (const auto& pair : sortedWordCounts) {
72
std::cout << pair.first << ": " << pair.second << std::endl;
73
}
74
75
return 0;
76
}
6.1.4 启发与分析
这个案例展示了如何使用 Prompt Engineering 快速生成一个实用的命令行工具。通过清晰地描述需求，LLM 生成了包含文件读取、单词统计、排序和输出等功能的完整 C++ 代码。这个例子可以启发我们，对于一些相对明确的任务，Prompt Engineering 可以极大地提高开发效率。
6.2 案例二：利用 Prompt 生成高效的数据排序算法
6.2.1 需求描述
我们需要一个高效的排序算法，能够对包含大量整数的 std::vector 进行排序。考虑到性能，我们希望使用快速排序算法。
6.2.2 使用 Prompt Engineering 生成代码
Prompt： “请生成一个 C++ 函数，名为 quickSortVector，该函数接收一个 std::vector<int> 类型的引用作为输入，并使用快速排序算法对其进行升序排序。请提供完整的函数实现。”
6.2.3 生成的代码
1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4
5
int partition(std::vector<int>& arr, int low, int high) {
6
int pivot = arr[high];
7
int i = (low - 1);
8
9
for (int j = low; j < high; j++) {
10
if (arr[j] < pivot) {
11
i++;
12
std::swap(arr[i], arr[j]);
13
}
14
}
15
std::swap(arr[i + 1], arr[high]);
16
return (i + 1);
17
}
18
19
void quickSortVector(std::vector<int>& arr, int low, int high) {
20
if (low < high) {
21
int pi = partition(arr, low, high);
22
23
quickSortVector(arr, low, pi - 1);
24
quickSortVector(arr, pi + 1, high);
25
}
26
}
27
28
void quickSortVector(std::vector<int>& arr) {
29
quickSortVector(arr, 0, arr.size() - 1);
30
}
31
32
// 一个简单的测试 main 函数（可以根据需要删除或修改）
33
int main() {
34
std::vector<int> data = {12, 11, 13, 5, 6, 7};
35
std::cout << "Original array: ";
36
for (int val : data) {
37
std::cout << val << " ";
38
}
39
std::cout << std::endl;
40
41
quickSortVector(data);
42
43
std::cout << "Sorted array: ";
44
for (int val : data) {
45
std::cout << val << " ";
46
}
47
std::cout << std::endl;
48
49
return 0;
50
}
6.2.4 启发与分析
这个案例展示了如何利用 Prompt Engineering 生成一个经典且高效的排序算法。通过明确指定算法名称和输入输出类型，LLM 能够生成正确的快速排序算法实现。这对于需要特定算法的场景非常有用，可以节省开发者从头实现的时间。
6.3 案例三：使用 Prompt 辅助构建小型 Web 服务器
6.3.1 需求描述
我们需要一个简单的 C++ Web 服务器，能够监听指定的端口，接收 HTTP GET 请求，并返回一个预定义的 HTML 页面。
6.3.2 使用 Prompt Engineering 生成代码
Prompt： “请生成一个简单的 C++ Web 服务器的代码，该服务器监听端口 8080。当接收到 HTTP GET 请求时，服务器应该返回一个包含 "<h1>Hello from C++ Web Server!</h1>" 的简单 HTML 页面。请使用 POSIX socket API，并包含基本的错误处理。”
6.3.3 生成的代码
1
#include <iostream>
2
#include <string>
3
#include <cstring>
4
#include <unistd.h>
5
#include <arpa/inet.h>
6
#include <sys/socket.h>
7
#include <netinet/in.h>
8
9
int main() {
10
int server_fd, new_socket;
11
struct sockaddr_in address;
12
int opt = 1;
13
socklen_t addrlen = sizeof(address);
14
char buffer[1024] = {0};
15
const char* response = "HTTP/1.1 200 OK\r\n"
16
"Content-Type: text/html\r\n"
17
"\r\n"
18
"<!DOCTYPE html><html><head><title>C++ Web Server</title></head><body><h1>Hello from C++ Web Server!</h1></body></html>";
19
20
// 创建 socket 文件描述符
21
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
22
std::cerr << "Socket creation failed" << std::endl;
23
return -1;
24
}
25
26
// 强制将 socket 绑定到端口和 IP 地址
27
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
28
std::cerr << "setsockopt failed" << std::endl;
29
close(server_fd);
30
return -1;
31
}
32
address.sin_family = AF_INET;
33
address.sin_addr.s_addr = INADDR_ANY;
34
address.sin_port = htons(8080);
35
36
// 将 socket 绑定到指定的端口
37
if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
38
std::cerr << "bind failed" << std::endl;
39
close(server_fd);
40
return -1;
41
}
42
43
// 开始监听连接
44
if (listen(server_fd, 3) < 0) {
45
std::cerr << "listen failed" << std::endl;
46
close(server_fd);
47
return -1;
48
}
49
std::cout << "Server listening on port 8080..." << std::endl;
50
51
while (true) {
52
if ((new_socket = accept(server_fd, (struct sockaddr*)&address, &addrlen)) < 0) {
53
std::cerr << "accept failed" << std::endl;
54
continue;
55
}
56
57
// 读取客户端的请求（这里只是简单读取，没有完整解析 HTTP 请求）
58
read(new_socket, buffer, 1024);
59
std::cout << "Request received." << std::endl;
60
61
// 发送 HTTP 响应
62
send(new_socket, response, strlen(response), 0);
63
std::cout << "Response sent." << std::endl;
64
65
close(new_socket);
66
}
67
68
close(server_fd);
69
return 0;
70
}
6.3.4 启发与分析
这个案例展示了如何使用 Prompt Engineering 快速搭建一个基本的 Web 服务器框架。通过指定监听端口、HTTP 方法和返回内容，LLM 生成了包含 socket 创建、绑定、监听、接受连接和发送响应等核心步骤的代码。虽然这个服务器非常简单，但它可以作为进一步开发更复杂 Web 应用的基础。
6.4 案例四：通过 Prompt 生成嵌入式系统驱动代码片段
6.4.1 需求描述
我们需要一个简单的 C++ 代码片段，用于控制一个连接到特定 GPIO 引脚的 LED 灯。假设 GPIO 引脚号为 18，我们需要能够设置 LED 灯的状态为高电平（点亮）或低电平（熄灭）。
6.4.2 使用 Prompt Engineering 生成代码
Prompt： “请生成一个 C++ 代码片段，用于控制连接到 GPIO 引脚 18 的 LED 灯。提供两个函数：turnOnLed() 将 GPIO 18 设置为高电平，turnOffLed() 将 GPIO 18 设置为低电平。假设我们运行在 Linux 环境下，可以使用 /sys/class/gpio 接口进行 GPIO 控制。请包含必要的头文件和错误处理。”
6.4.3 生成的代码
1
#include <iostream>
2
#include <fstream>
3
#include <string>
4
5
const std::string GPIO_PATH = "/sys/class/gpio";
6
const std::string GPIO_PIN = "18";
7
8
bool writeToFile(const std::string& path, const std::string& value) {
9
std::ofstream file(path);
10
if (file.is_open()) {
11
file << value;
12
file.close();
13
return true;
14
} else {
15
std::cerr << "Error opening file: " << path << std::endl;
16
return false;
17
}
18
}
19
20
bool exportGpio() {
21
std::string exportPath = GPIO_PATH + "/export";
22
return writeToFile(exportPath, GPIO_PIN);
23
}
24
25
bool unexportGpio() {
26
std::string unexportPath = GPIO_PATH + "/unexport";
27
return writeToFile(unexportPath, GPIO_PIN);
28
}
29
30
bool setGpioDirection(const std::string& direction) {
31
std::string directionPath = GPIO_PATH + "/gpio" + GPIO_PIN + "/direction";
32
return writeToFile(directionPath, direction);
33
}
34
35
bool setGpioValue(const std::string& value) {
36
std::string valuePath = GPIO_PATH + "/gpio" + GPIO_PIN + "/value";
37
return writeToFile(valuePath, value);
38
}
39
40
void turnOnLed() {
41
if (setGpioValue("1")) {
42
std::cout << "LED on (GPIO " << GPIO_PIN << " set to high)" << std::endl;
43
} else {
44
std::cerr << "Error setting GPIO " << GPIO_PIN << " value to high" << std::endl;
45
}
46
}
47
48
void turnOffLed() {
49
if (setGpioValue("0")) {
50
std::cout << "LED off (GPIO " << GPIO_PIN << " set to low)" << std::endl;
51
} else {
52
std::cerr << "Error setting GPIO " << GPIO_PIN << " value to low" << std::endl;
53
}
54
}
55
56
// 注意：在使用前可能需要先导出 GPIO 引脚并设置方向
57
// 可以在 main 函数中调用 exportGpio() 和 setGpioDirection("out");
58
// 在程序结束时调用 unexportGpio();
59
60
// int main() {
61
// if (exportGpio() && setGpioDirection("out")) {
62
// turnOnLed();
63
// // std::this_thread::sleep_for(std::chrono::seconds(5));
64
// turnOffLed();
65
// unexportGpio();
66
// return 0;
67
// } else {
68
// std::cerr << "Failed to initialize GPIO " << GPIO_PIN << std::endl;
69
// return 1;
70
// }
71
// }
6.4.4 启发与分析
这个案例展示了如何使用 Prompt Engineering 生成特定于嵌入式系统的代码片段。通过描述硬件接口（GPIO 引脚）和操作系统环境（Linux /sys/class/gpio），LLM 能够生成操作 GPIO 的 C++ 代码。这对于嵌入式系统开发者来说非常有用，可以快速生成与硬件交互的基础代码。
6.5 案例五：利用 Prompt 进行代码重构与优化
6.5.1 需求描述
我们有一段实现了简单加法功能的 C++ 代码，但其可读性较差，并且没有进行必要的输入验证。我们需要对其进行重构，提高可读性，并添加输入验证功能。
6.5.2 使用 Prompt Engineering 进行重构
原始代码（假设）：
1
#include <iostream>
2
int main(){int a,b;std::cin>>a>>b;std::cout<<a+b<<std::endl;return 0;}
Prompt： “请重构以下 C++ 代码，使其更易读，并添加输入验证功能，确保用户输入的是整数。如果输入不是整数，则输出错误信息并退出程序。
1
#include <iostream>
2
int main(){int a,b;std::cin>>a>>b;std::cout<<a+b<<std::endl;return 0;}
”
6.5.3 生成的重构后的代码
1
#include <iostream>
2
#include <limits> // 用于清除输入缓冲区
3
4
int main() {
5
int num1, num2;
6
7
std::cout << "Enter the first integer: ";
8
std::cin >> num1;
9
10
// 输入验证
11
if (std::cin.fail()) {
12
std::cerr << "Error: Invalid input. Please enter an integer." << std::endl;
13
std::cin.clear(); // 清除错误标志
14
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 忽略剩余的输入
15
return 1;
16
}
17
18
std::cout << "Enter the second integer: ";
19
std::cin >> num2;
20
21
// 输入验证
22
if (std::cin.fail()) {
23
std::cerr << "Error: Invalid input. Please enter an integer." << std::endl;
24
std::cin.clear(); // 清除错误标志
25
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 忽略剩余的输入
26
return 1;
27
}
28
29
int sum = num1 + num2;
30
std::cout << "The sum is: " << sum << std::endl;
31
32
return 0;
33
}
6.5.4 启发与分析
这个案例展示了如何使用 Prompt Engineering 辅助进行代码重构和优化。通过提供原始代码和明确的重构要求（提高可读性和添加输入验证），LLM 生成了更清晰、更健壮的代码。这表明 Prompt Engineering 不仅可以用于生成新代码，还可以用于改进现有代码。
本章通过五个不同的实战案例，展示了 Prompt Engineering 在 C++ 代码生成中的广泛应用。从快速生成简单的命令行工具到辅助构建 Web 服务器，再到生成嵌入式系统驱动代码片段以及进行代码重构，这些案例都体现了 Prompt Engineering 的实用性和潜力。读者可以从这些案例中获得启发，思考如何将 Prompt Engineering 应用到自己的实际项目中，以提高开发效率和代码质量。在下一章，我们将探讨 Prompt Engineering 在更大型的 C++ 项目开发中的应用。
7. chapter 7： Prompt Engineering 在 C++ 项目开发中的应用
7.1 自动化生成样板代码（Boilerplate Code）
7.1.1 什么是样板代码？
在软件开发中，样板代码（Boilerplate Code）指的是在多个地方重复出现，结构相似但具体内容略有不同的代码片段。例如，类的 Getter 和 Setter 方法、简单的构造函数、日志记录语句等。编写这些重复性的代码既耗时又容易出错。
7.1.2 如何使用 Prompt Engineering 自动化生成样板代码
Prompt Engineering 可以通过定义清晰的 Prompt 模板，自动化生成这些样板代码，从而提高开发效率，减少手动编写的工作量。
示例 1：生成类的 Getter 和 Setter 方法
Prompt Template： “请为以下 C++ 类 {className} 生成私有成员变量 {variableName}（类型为 {variableType}）的公有 Getter 方法 get{VariableName}() 和 Setter 方法 set{VariableName}({variableType} value)。”
应用： 假设我们有一个 Person 类，需要为其 name（std::string）和 age（int）成员变量生成 Getter 和 Setter 方法。
Prompt 1： “请为以下 C++ 类 Person 生成私有成员变量 name（类型为 std::string）的公有 Getter 方法 getName() 和 Setter 方法 setName(std::string value)。”
生成的代码：
1
#include <string>
2
3
class Person {
4
private:
5
std::string name;
6
7
public:
8
std::string getName() const {
9
return name;
10
}
11
12
void setName(const std::string& value) {
13
name = value;
14
}
15
};
Prompt 2： “请为以下 C++ 类 Person 生成私有成员变量 age（类型为 int）的公有 Getter 方法 getAge() 和 Setter 方法 setAge(int value)。”
生成的代码：
1
class Person {
2
private:
3
int age;
4
5
public:
6
int getAge() const {
7
return age;
8
}
9
10
void setAge(int value) {
11
age = value;
12
}
13
};
示例 2：生成简单的构造函数
Prompt Template： “请为以下 C++ 类 {className} 生成一个构造函数，该构造函数接收参数 {parameterDeclarations} 并将其赋值给对应的私有成员变量。”
应用： 为 Rectangle 类生成一个接收 width 和 height 的构造函数。
Prompt： “请为以下 C++ 类 Rectangle 生成一个构造函数，该构造函数接收参数 double width 和 double height 并将其赋值给对应的私有成员变量。”
生成的代码：
1
class Rectangle {
2
private:
3
double width;
4
double height;
5
6
public:
7
Rectangle(double width, double height) : width(width), height(height) {}
8
};
7.1.3 启发与分析
通过使用 Prompt 模板，可以快速生成大量重复性的样板代码，从而节省开发时间，并降低因手动编写而引入错误的风险。
7.2 辅助生成测试用例（Test Cases）
7.2.1 单元测试的重要性
单元测试是保证软件质量的关键环节。编写全面的测试用例可以帮助我们尽早发现和修复代码中的缺陷。
7.2.2 如何使用 Prompt Engineering 辅助生成测试用例
Prompt Engineering 可以根据函数或类的功能描述，自动生成一些基本的测试用例，覆盖常见场景和边界情况。
示例： 假设我们有一个计算阶乘的函数 factorial(int n)。
Prompt： “请为以下 C++ 函数 int factorial(int n) 生成一些单元测试用例，包括正常输入、边界输入（例如 0 和 1）以及可能的错误输入（例如负数）。可以使用 Google Test 框架。”
生成的代码：
1
#include "gtest/gtest.h"
2
#include "your_code.h" // 假设 factorial 函数在 your_code.h 中声明
3
4
TEST(FactorialTest, HandlesZero) {
5
EXPECT_EQ(1, factorial(0));
6
}
7
8
TEST(FactorialTest, HandlesOne) {
9
EXPECT_EQ(1, factorial(1));
10
}
11
12
TEST(FactorialTest, HandlesPositiveNumber) {
13
EXPECT_EQ(120, factorial(5));
14
}
15
16
TEST(FactorialTest, HandlesNegativeNumber) {
17
// 阶乘通常对负数没有定义，可以根据具体需求处理
18
// 这里假设返回一个特定的错误值或者抛出异常
19
// 例如，如果函数返回 -1 表示错误：
20
EXPECT_EQ(-1, factorial(-1));
21
}
22
23
// 可以添加更多测试用例，例如更大的正数
7.2.3 启发与分析
Prompt Engineering 可以根据函数的功能描述，生成一些基本的单元测试用例框架，开发者可以在此基础上进行补充和完善，覆盖更多的测试场景。这可以大大减轻编写测试用例的工作量，提高测试覆盖率。
7.3 快速生成文档注释（Documentation Comments）
7.3.1 文档注释的重要性
良好的文档注释对于代码的理解和维护至关重要。它可以帮助其他开发者（以及未来的自己）快速了解代码的功能、参数和返回值等信息。
7.3.2 如何使用 Prompt Engineering 快速生成文档注释
Prompt Engineering 可以根据函数或类的签名，自动生成符合特定格式（例如 Doxygen）的文档注释。
示例： 假设我们有一个计算两个整数之和的函数：
1
int add(int a, int b);
Prompt： “请为以下 C++ 函数生成 Doxygen 风格的文档注释：int add(int a, int b);”
生成的代码：
1
/**
2
* @brief 计算两个整数的和。
3
*
4
* @param a 第一个整数。
5
* @param b 第二个整数。
6
* @return 两个整数的和。
7
*/
8
int add(int a, int b);
示例： 假设我们有一个表示点的类：
1
class Point {
2
private:
3
int x;
4
int y;
5
6
public:
7
Point(int x_val, int y_val);
8
int getX() const;
9
int getY() const;
10
};
Prompt： “请为以下 C++ 类 Point 生成 Doxygen 风格的文档注释，包括类描述、构造函数描述以及每个成员函数的描述。”
生成的代码：
1
/**
2
* @brief 表示二维空间中的一个点。
3
*
4
* 该类包含点的 x 和 y 坐标。
5
*/
6
class Point {
7
private:
8
int x; ///< x 坐标
9
int y; ///< y 坐标
10
11
public:
12
/**
13
* @brief 构造一个 Point 对象。
14
*
15
* @param x_val x 坐标的初始值。
16
* @param y_val y 坐标的初始值。
17
*/
18
Point(int x_val, int y_val);
19
20
/**
21
* @brief 获取点的 x 坐标。
22
*
23
* @return 点的 x 坐标。
24
*/
25
int getX() const;
26
27
/**
28
* @brief 获取点的 y 坐标。
29
*
30
* @return 点的 y 坐标。
31
*/
32
int getY() const;
33
};
7.3.3 启发与分析
Prompt Engineering 可以根据代码结构和命名，快速生成符合规范的文档注释，大大减少了手动编写文档的工作量，提高了代码文档的质量和一致性。
7.4 利用 Prompt 进行代码审查（Code Review）辅助
7.4.1 代码审查的重要性
代码审查是提高代码质量、发现潜在缺陷和促进团队知识共享的重要实践。
7.4.2 如何使用 Prompt Engineering 辅助代码审查
Prompt Engineering 可以用于分析代码片段，并根据预定义的规则或最佳实践，提出潜在的改进建议。
示例： 假设我们有以下代码片段：
1
#include <iostream>
2
#include <vector>
3
4
int main() {
5
std::vector<int> numbers;
6
for (int i = 0; i < 10; ++i) {
7
numbers.push_back(i);
8
}
9
10
for (int i = 0; i < numbers.size(); ++i) {
11
std::cout << numbers[i] << " ";
12
}
13
std::cout << std::endl;
14
15
return 0;
16
}
Prompt： “请分析以下 C++ 代码片段，并提出任何可以改进的地方，例如代码风格、潜在的性能问题或可以更简洁的写法。
1
#include <iostream>
2
#include <vector>
3
4
int main() {
5
std::vector<int> numbers;
6
for (int i = 0; i < 10; ++i) {
7
numbers.push_back(i);
8
}
9
10
for (int i = 0; i < numbers.size(); ++i) {
11
std::cout << numbers[i] << " ";
12
}
13
std::cout << std::endl;
14
15
return 0;
16
}
”
可能的分析结果（由 LLM 生成）：
这段代码的功能是创建一个包含数字 0 到 9 的 std::vector 并打印出来。以下是一些可以改进的地方：
- 代码风格： 可以考虑在
for循环中使用基于范围的 for 循环，使代码更简洁易读。 - 性能： 对于简单的数值填充，可以使用
std::iota来更高效地初始化vector。 - 简洁性： 打印
vector的元素可以使用std::copy和std::ostream_iterator。
改进后的代码建议：
1
#include <iostream>
2
#include <vector>
3
#include <numeric> // 引入 std::iota
4
#include <algorithm> // 引入 std::copy
5
#include <iterator> // 引入 std::ostream_iterator
6
7
int main() {
8
std::vector<int> numbers(10);
9
std::iota(numbers.begin(), numbers.end(), 0); // 使用 iota 填充 vector
10
11
// 使用基于范围的 for 循环打印
12
for (int number : numbers) {
13
std::cout << number << " ";
14
}
15
std::cout << std::endl;
16
17
// 或者使用 std::copy 和 std::ostream_iterator 打印
18
std::copy(numbers.begin(), numbers.end(), std::ostream_iterator<int>(std::cout, " "));
19
std::cout << std::endl;
20
21
return 0;
22
}
7.4.3 启发与分析
Prompt Engineering 可以作为代码审查的辅助工具，帮助开发者发现代码中潜在的改进点，提高代码质量。
7.5 将 Prompt Engineering 集成到 CI/CD 流程中
7.5.1 CI/CD 的重要性
持续集成（Continuous Integration, CI）和持续交付/部署（Continuous Delivery/Deployment, CD）是现代软件开发的关键实践，可以提高软件发布的频率和可靠性。
7.5.2 如何将 Prompt Engineering 集成到 CI/CD 流程中
Prompt Engineering 可以集成到 CI/CD 流程的多个环节，例如：
① 自动化生成代码片段：在构建过程中，根据配置文件或需求描述，自动生成某些样板代码或配置文件。
② 自动化生成测试用例：在测试阶段，根据代码变更自动生成或更新相关的测试用例。
③ 自动化生成文档：在文档生成阶段，根据代码注释自动生成 API 文档。
④ 代码质量检查辅助：在代码审查环节，利用 Prompt Engineering 分析代码质量并生成报告。
7.5.3 示例：在 CI 过程中自动化生成文档注释
假设我们的 CI 流程包含一个步骤，用于生成代码文档。我们可以编写一个脚本，该脚本遍历代码仓库中的 C++ 文件，提取函数和类的签名，然后使用 Prompt Engineering 自动生成 Doxygen 风格的文档注释，并将这些注释添加到代码中。
7.5.4 启发与分析
将 Prompt Engineering 集成到 CI/CD 流程中可以实现开发的自动化，提高开发效率和软件质量。例如，自动化生成文档可以确保文档与代码保持同步，自动化生成测试用例可以提高测试覆盖率。
本章探讨了 Prompt Engineering 在 C++ 项目开发中的多个应用场景，包括自动化生成样板代码、辅助生成测试用例、快速生成文档注释、辅助代码审查以及集成到 CI/CD 流程中。这些应用展示了 Prompt Engineering 在提高开发效率、保证代码质量和降低维护成本方面的巨大潜力。在下一章，我们将展望 Prompt Engineering 的未来趋势与挑战。
8. chapter 8： Prompt Engineering 的未来趋势与挑战
8.1 更智能的代码生成模型
8.1.1 模型能力的持续提升
随着深度学习技术的不断发展，我们有理由相信未来的代码生成模型将变得更加智能和强大。这些模型将具备更强的理解能力，能够更好地理解用户在 Prompt 中表达的意图，并生成更复杂、更准确、更高效的 C++ 代码。
8.1.2 支持更高级的编程概念
未来的模型可能会更好地理解和生成涉及更高级 C++ 概念的代码，例如模板元编程（Template Metaprogramming）、并发编程（Concurrent Programming）、智能指针（Smart Pointers）、异常安全（Exception Safety）等。
8.1.3 更好的上下文理解和代码补全
未来的模型有望在理解上下文信息方面取得更大的突破，能够更好地利用已有的代码库、项目结构和编码规范，生成更连贯、更符合项目整体风格的代码片段，甚至实现更智能的代码补全功能。
8.1.4 个性化和定制化
未来的模型可能会更加个性化和定制化，能够根据开发者的个人偏好、团队的特定需求和项目的具体特点，生成定制化的 C++ 代码。
8.2 Prompt Engineering 的自动化与智能化
8.2.1 自动化 Prompt 设计
目前，设计一个有效的 Prompt 往往需要一定的经验和技巧。未来的趋势可能是出现更智能的工具或平台，能够根据用户的需求和目标，自动生成或推荐合适的 Prompt。
8.2.2 智能 Prompt 优化
模型本身也可能会具备一定的 Prompt 优化能力，能够分析用户输入的 Prompt，并提出改进建议，以获得更好的代码生成结果。
8.2.3 基于反馈的迭代优化
未来的 Prompt Engineering 流程可能会更加智能化，能够根据用户对生成代码的反馈（例如修改、采纳、拒绝），自动调整和优化 Prompt，从而不断提高代码生成的质量。
8.2.4 Prompt 工程平台的出现
可能会出现专门的 Prompt 工程平台，提供 Prompt 的创建、管理、共享、评估和优化等功能，方便开发者更好地利用 Prompt Engineering 技术。
8.3 面临的挑战与潜在的解决方案
8.3.1 生成代码的正确性和可靠性
尽管代码生成模型的能力不断提升，但目前生成的代码仍然可能存在错误、逻辑缺陷或性能问题。如何确保生成代码的正确性和可靠性仍然是一个重要的挑战。
潜在的解决方案：
① 更严格的 Prompt 设计：通过更清晰、更具体的 Prompt 指导模型生成正确的代码。
② 自动化测试集成：将自动化测试集成到代码生成流程中，对生成的代码进行验证。
③ 形式化验证方法：探索使用形式化验证等方法来证明生成代码的正确性。
④ 人类专家参与：在关键环节引入人类专家进行审查和确认。
8.3.2 生成代码的效率和性能
某些情况下，LLM 生成的代码可能效率不高或性能较差。如何引导模型生成更高效、更优化的 C++ 代码是一个挑战。
潜在的解决方案：
① 在 Prompt 中明确指定性能要求：例如，“生成一个高效的算法”、“使用低延迟的数据结构”等。
② 提供性能优化的示例：通过 Few-Shot Prompting 展示高效代码的写法。
③ 集成代码分析工具：在代码生成后，使用静态分析工具或性能分析工具对生成的代码进行评估和优化。
8.3.3 生成代码的可读性和可维护性
LLM 生成的代码有时可能难以阅读和维护。如何引导模型生成符合良好编码规范、易于理解和修改的代码是一个挑战。
潜在的解决方案：
① 在 Prompt 中指定编码规范：例如，“遵循 Google C++ Style Guide”、“添加详细的注释”等。
② 提供高质量的代码示例：通过 Few-Shot Prompting 展示良好的编码风格。
③ 集成代码格式化工具：在代码生成后，使用代码格式化工具（例如 clang-format）对代码进行规范化。
8.3.4 模型对 C++ 领域知识的掌握程度
C++ 是一门复杂的编程语言，涉及到许多底层的概念和复杂的特性。模型对这些知识的掌握程度直接影响其代码生成的能力。
潜在的解决方案：
① 使用更多高质量的 C++ 代码数据进行模型训练。
② 利用外部知识库和 API 文档，增强模型对 C++ 相关知识的理解。
③ 针对 C++ 代码生成任务进行模型微调（Fine-tuning）。
8.3.5 安全性问题
类似于其他 AI 应用，代码生成模型也可能存在生成不安全代码的风险，例如包含漏洞或恶意代码。
潜在的解决方案：
① 在模型训练阶段加入安全性相关的约束和数据。
② 对生成的代码进行安全漏洞扫描。
③ 引导模型生成符合安全编码规范的代码。
8.4 对 C++ 开发者技能的新要求
随着 Prompt Engineering 在 C++ 代码生成中的应用越来越广泛，对 C++ 开发者的技能也提出了新的要求：
① Prompt 设计能力：开发者需要学会如何编写清晰、具体、有效的 Prompt，以指导模型生成期望的代码。
② 代码审查能力：开发者需要具备审查和验证 LLM 生成代码的能力，确保其正确性、可靠性和安全性。
③ 问题分解能力：对于复杂的问题，开发者需要学会如何将其分解为更小的子问题，并设计相应的 Prompt 序列来逐步解决。
④ 与 AI 协作的能力：开发者需要学会如何与代码生成模型高效地协作，将 Prompt Engineering 作为开发过程中的一个有力工具。
本章探讨了 Prompt Engineering 在 C++ 代码生成领域的未来趋势和面临的挑战。尽管存在一些挑战，但随着技术的不断进步，我们有理由相信 Prompt Engineering 将在未来的 C++ 开发中发挥越来越重要的作用，并对开发者的技能提出新的要求。在最后一章，我们将对本书的核心内容进行总结，并展望 Prompt Engineering 在 C++ 开发中的未来。
9. chapter 9： 总结与展望
9.1 本书核心知识点回顾
在本书中，我们深入探讨了 Prompt Engineering 在 C++ 代码生成领域的应用。我们从 Prompt Engineering 的基本概念入手，了解了其在 C++ 开发中的重要意义。随后，我们学习了设计有效 Prompt 的基础技巧，包括编写清晰明确的指令、有效利用上下文信息、指定输出格式与结构、使用关键词和约束条件以及进行迭代优化。
我们重点介绍了 C++ 代码生成的核心 Prompt 策略，涵盖了生成基本语法结构、函数和类、控制流语句以及常用数据结构和算法。通过丰富的实例，我们展示了如何利用 Prompt Engineering 解决面向特定任务的 C++ 编程问题，例如文件操作、字符串处理、网络编程、数据库操作以及简单的游戏逻辑。
此外，我们还探讨了 Prompt Engineering 的高级技巧与应用，包括使用 Few-Shot Prompting 进行复杂代码生成、利用思维链进行问题分解、集成外部知识与 API 文档、处理代码生成中的错误与异常以及生成符合特定编码规范的代码。
最后，我们通过多个实战案例分析，进一步巩固了所学的知识，并探讨了 Prompt Engineering 在实际 C++ 项目开发中的应用，例如自动化生成样板代码、辅助生成测试用例和文档注释、辅助代码审查以及集成到 CI/CD 流程中。
9.2 Prompt Engineering 在 C++ 开发中的价值
通过本书的学习，我们可以清晰地认识到 Prompt Engineering 为 C++ 开发带来了诸多价值：
① 提高开发效率：能够快速生成代码片段、样板代码和解决方案，缩短开发周期。
② 降低入门门槛：可以作为初学者学习 C++ 的辅助工具，帮助理解语法和编程模式。
③ 激发创新思维：能够生成不同的代码实现方案，为开发者提供新的思路和灵感。
④ 自动化重复性任务：可以自动化生成测试用例、文档注释等，解放开发者的生产力。
⑤ 辅助代码审查：能够分析代码并提出改进建议，提高代码质量。
9.3 对读者的寄语与未来学习建议
Prompt Engineering 是一项新兴且充满潜力的技术，尤其在快速发展的 AI 领域，其重要性日益凸显。我们希望本书能够帮助读者掌握 Prompt Engineering 的基本原理和在 C++ 代码生成中的应用技巧。
对于未来的学习，我们建议读者：
① 持续关注最新的技术发展：Prompt Engineering 和 LLM 技术都在快速发展，保持对最新研究成果和工具的关注至关重要。
② 多加实践和探索：理论知识的学习固然重要，但更重要的是将所学知识应用到实际项目中，通过实践不断积累经验。
③ 参与社区交流：与其他开发者交流 Prompt Engineering 的经验和技巧，共同进步。
④ 尝试不同的 LLM 和 Prompt Engineering 工具：不同的模型和工具可能具有不同的特点和优势，尝试使用它们可以帮助我们更好地理解和利用 Prompt Engineering。
我们相信，随着技术的不断成熟和应用场景的不断拓展，Prompt Engineering 将在未来的 C++ 开发中扮演越来越重要的角色，成为每一位 C++ 开发者工具箱中不可或缺的一部分。希望本书能够成为您探索和掌握 Prompt Engineering 的良好开端，祝您在 C++ 开发的道路上取得更大的成就！