C++ on kenji.blog

【完全解剖】使用C++实现并理解最强密码破解算法「GNFS」

Sat, 05 Sep 2026 13:04:59 +0900

【完全解剖】使用C++实现并理解最强密码破解算法「GNFS」

支撑现代互联网根基的「RSA加密」。其坚固性依赖于一种数学信念：“以目前的计算机，想要对巨大的合数进行素数分解实际上是不可能的”。

然而，人类从未放弃。如今，在经典计算机（非量子计算机）上，存在着一种用于进行巨大素数分解的 **人类最强、最尖端的算法 **。那就是 「一般数域筛选法（GNFS：General Number Field Sieve）」。

本文将完全公开使用C++（使用了Boost库的多精度整数 boost::multiprecision）严格建模这一GNFS最尖端计算逻辑的实现代码，并彻底解说其背后的「代数数论」深渊。

请务必结合源代码，尽情领略数学的神秘以及将其征服的计算机科学的暴力美学。

1. GNFS 最尖端逻辑框架（完整源代码）

首先，展示本次要解说的GNFS C++实现的整体面貌。实际的数域筛选法（如CADO-NFS等）是长达数十万行的超大型分布式系统，而本代码提取了构成GNFS的 「5个必备流水线（阶段）」 进行类设计，并在不丢失数学意义的前提下以最小结构进行了建模。

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227


#include <iostream>
#include <vector>
#include <cmath>
#include <map>
#include <set>
#include <chrono>
#include <boost/multiprecision/cpp_int.hpp>

// 使用Boost.Multiprecision的多精度整数
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve (一般数域筛选法) 最尖端逻辑框架
//
// 本代码将CADO-NFS等使用的最尖端GNFS的5个流水线
// 严格建模为C++ (Boost) 的类设计。
// ============================================================================

struct Relation {
 int64_t a;
 int64_t b;
 std::vector<uint32_t> rational_primes;
 std::vector<uint32_t> algebraic_primes;
};

// ============================================================================
// Phase 1: Polynomial Selection (KleinJung算法)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // 代数侧多项式 f(x)
 std::vector<cpp_int> g; // 有理侧多项式 g(x) = x - m
 cpp_int m;

 PolynomialSelector(int d) : degree(d) {}

 // 基于 base-m 展开生成初始多项式 (实际使用更高级的格基规约 LLL)
 void select(const cpp_int& N) {
 std::cout << "[Phase 1] Polynomial Selection (Degree " << degree << ") starting..." << std::endl;
 // 简单的 base-m 展开 (d次)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // 简单的m估算 (不使用Boost函数的近似)
 cpp_int low = 1, high = N;
 while (low <= high) {
 cpp_int mid = low + (high - low) / 2;
 cpp_int p = 1;
 for(int i=0; i<degree; ++i) p *= mid;
 if (p <= N) { m = mid; low = mid + 1; }
 else { high = mid - 1; }
 }

 f.resize(degree + 1);
 cpp_int temp = N;
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }

 g = {-m, 1}; // g(x) = x - m

 std::cout << " -> m = " << m << std::endl;
 std::cout << " -> f(x) = ";
 for(int i = degree; i >= 0; --i) {
 std::cout << f[i] << "x^" << i << (i > 0 ? " + " : "");
 }
 std::cout << "\n[Phase 1] Complete." << std::endl;
 }
};

// ============================================================================
// Phase 2: Lattice Sieving (格筛选法)
// ============================================================================
// 近年的GNFS中，相较于线筛选 (Line Sieve)，Franke-Kleinjung等人的
// 特殊q格筛选 (Special-q Lattice Sieving) 是事实上的标准。
class LatticeSieve {
 uint32_t rational_bound;
 uint32_t algebraic_bound;
 std::vector<uint32_t> rational_fb;
 std::vector<uint32_t> algebraic_fb;

public:
 LatticeSieve(uint32_t rb, uint32_t ab) : rational_bound(rb), algebraic_bound(ab) {}

 void generate_factor_bases() {
 std::cout << "[Phase 2] Generating Factor Bases (Rational Bound: " << rational_bound << ", Algebraic Bound: " << algebraic_bound << ")" << std::endl;
 // (省略) 实际上会进行素数生成以及利用勒让德符号等进行过滤
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Phase 2] Special-q Lattice Sieving active..." << std::endl;
 std::vector<Relation> relations;
 // 模拟实现: 实际的格筛选会以块为单位扫描数百GB的内存空间
 // 将 (a, b) 的对映射到每个特殊素数 q 的格子 (a = i*q + j*...) 上，
 // 执行将缓存效率提升到极限的筛选。

 // 为演示添加一个虚拟关系
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Phase 2] Found " << relations.size() << " relations." << std::endl;
 return relations;
 }
};

// ============================================================================
// Phase 3: Filtering (奇异点清除与团合并)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Phase 3] Filtering Relations..." << std::endl;
 // 1. Singleton removal (删除仅出现1次的素数所对应的关系)
 // 2. Clique merging (合并关系以使稀疏矩阵变稠密)
 // 实际上会使用并查集等算法将数亿行的矩阵压缩到数百万行。
 std::cout << "[Phase 3] Matrix size reduced optimally." << std::endl;
 }
};

// ============================================================================
// Phase 4: Linear Algebra over GF(2) (Block Wiedemann 法)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // 在近年的超算环境中，比起 Block Lanczos 法，更适合分布式计算的
 // Block Wiedemann 法 (Coppersmith实现) 被作为最尖端技术使用。
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Phase 4] Block Wiedemann algorithm over GF(2) starting..." << std::endl;
 // 迭代进行稀疏矩阵与向量的乘积运算，
 // 找到多个满足 M * x = 0 mod 2 的解向量(零空间)。

 std::vector<std::vector<int>> dependencies; // 依赖关系列表
 // 虚拟数据
 dependencies.push_back({0});

 std::cout << "[Phase 4] Found " << dependencies.size() << " linear dependencies (perfect squares)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Phase 5: Algebraic Square Root (代数平方根)
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Phase 5] Algebraic Square Root computation..." << std::endl;

 // 1. 有理侧平方根 V 的计算 (简单的整数运算)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. 代数侧平方根 gamma 的计算 (Montgomery法等)
 // 求出巨大代数域 O_K 的元素 gamma，并通过同态映射 phi 映射到现实世界
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // 为了回避理想类群与单位群的障碍(Obstruction)，
 // 前提是在Phase 2和4中添加了二次剩余特征(Quadratic Characters)的列。

 std::cout << " -> Homomorphism map phi applied." << std::endl;
 std::cout << "[Phase 5] Calculating GCD(V - Y, N)..." << std::endl;

 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)

 if (factor > 1 && factor < N) {
 std::cout << "\n================================================================" << std::endl;
 std::cout << "[SUCCESS] Non-trivial factor found: " << factor << std::endl;
 std::cout << " Other factor: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[FAILURE] Trivial solution. Trying next dependency..." << std::endl;
 }
 }
};

// ============================================================================
// Main Execution Pipeline
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] General Number Field Sieve Engine (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // 想要进行素数分解的巨大合数 N (如 RSA-270 等)
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // 多项式的次数 (超过130位时通常选择 5次～6次)
 int degree = 6;

 // 初始化流水线
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // 实际的界限在数千万到数亿
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

 auto start_time = std::chrono::high_resolution_clock::now();

 // 1. 多项式选择
 poly_select.select(N);

 // 2. 筛选 (Sieve) 处理
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. 过滤 (矩阵压缩)
 filter.reduce_matrix(relations);

 // 4. 线性代数 (GF(2)上的零空间搜索)
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. 代数平方根的计算与GCD
 for (const auto& dep : dependencies) {
 sqrt_step.compute_and_factor(relations, dep, N);
 }

 auto end_time = std::chrono::high_resolution_clock::now();
 std::chrono::duration<double> elapsed = end_time - start_time;
 std::cout << "\n[System] SOTA GNFS Pipeline completed in " << elapsed.count() << " seconds." << std::endl;

 return 0;
}

那么，这段代码究竟是如何突破加密壁垒的呢？接下来，我们将按5个阶段，将其严密的算法与高深的数学揉碎了进行解说。

2. GNFS的最终目的： $X^2 \equiv Y^2 \pmod N$

不仅是GNFS，现代巨大的素因数分解算法几乎都在追求一个共同的目标：找到满足以下同余式的非平凡对 $(X, Y)$。

$$X^2 \equiv Y^2 \pmod N$$

这个式子意味着，“$X^2$ 和 $Y^2$ 除以 $N$ 的余数相等”。将其变形可得， $X^2 - Y^2 \equiv 0 \pmod N$ 也就是说，$(X-Y)(X+Y)$ 是 $N$ 的倍数。

如果 $X \not\equiv \pm Y \pmod N$（非平凡解），那么在 $(X-Y)$ 和 $N$ 之间就存在一个“大于1且小于 $N$ 的公约数”。此时，使用辗转相除法计算 $\gcd(X-Y, N)$，就可以轻而易举地求出 $N$ 的素因子。

然而，要找到这样的 $X$ 和 $Y$ 无异于大海捞针。因此GNFS采取了一种天才般的方法，即创造出“现实的整数世界”和“多项式的代数域世界” 这两个世界，并将计算分散开来。

3. Phase 1: 多项式选择（Polynomial Selection）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // m = N^(1/d) 的计算与 base-m 展开
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

GNFS的第一步，是构建连接两个世界的“魔法多项式”。对于巨大的数 $N$，我们选取一个整数 $m$。通常选取 $m \approx N^{1/d}$（代码中假设为 $d=6$ 次多项式）。

然后，将 $N$ 展开为 $m$ 进制，利用其系数构建多项式 $f(x)$。

$$N = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$$ $$f(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_1 x + c_0$$

这个多项式 $f(x)$ 具有一个极其重要的性质：“当变量 $x$ 代入 $m$ 时，结果正好是 $N$（$f(m) = N$）”。换句话说，$f(m) \equiv 0 \pmod N$。有理侧的多项式定义为 $g(x) = x - m$。

这样，由 $f(x)=0$ 的根 $\alpha$ 所支配的 “代数域世界 $\mathbb{Z}[\alpha]$”，与普通的 “有理数（整数）世界 $\mathbb{Z}$”，通过 $x \to m$ 的“环同态映射（Homomorphism）”被紧密地连接在了一起。

在最尖端的CADO-NFS等实现中，会花费数月时间，利用KleinJung算法或LLL格基规约算法，去搜索一个多项式系数不会极大，并且在后续步骤中更容易出现素数（更容易平滑）的“最合适的多项式 $f(x)$”。

4. Phase 2: 特殊 $q$ 格筛选法（Special-q Lattice Sieving）

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // 将 (a, b) 的对映射到每个特殊素数 q 的格子中，
 // 执行将缓存效率提升到极限的筛选。
 // ...
 }
};

准备好两个世界后，下一步就是在这两个世界中寻找“平滑数（仅由小素数组成的数）”。生成无数个整数对 $(a, b)$，并计算以下两个值：

有理侧的值 ： $a - bm$
代数侧的范数 ： $b^d f(a/b)$

GNFS的目的是收集几千万到几亿个 “有理侧和代数侧的值都能被小素因子完全分解的整数对（Relation：关系）”。

在早期的GNFS中，使用“线筛选（Line Sieve）”，即把 $(a, b)$ 排列在 $xy$ 平面上，从头开始依次用素数去除。然而，这种做法会导致在内存各处跳跃访问，引发频繁的缓存未命中，速度非常慢。

因此，在当前的尖端代码中使用了 “特殊 $q$ 格筛选（Special-q Lattice Sieve）” 技术。固定一个适度大的素数 $q$，只把那些“代数侧的值必然能被 $q$ 整除的 $(a, b)$ 对”作为计算对象。满足这个条件的 $(a, b)$ 在平面上形成了一个“格子（Lattice）”，使得计算内存地址的跳跃幅度固定，完美契合CPU的L1/L2缓存。通过引入格筛选，GNFS的计算速度得到了戏剧性的提升。

5. Phase 3: 过滤（Filtering）

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Singleton removal (删除仅出现1次的素数所对应的关系)
 // 2. Clique merging (合并关系以使稀疏矩阵变稠密)
 }
};

Phase 2中全球计算机花费数月收集到的数亿个关系。但是，如果直接将这些关系丢给下一个“解方程组步骤（矩阵计算）”，超级计算机的内存也会被撑爆。

因此，需要进行称为 Filtering（过滤） 的矩阵超压缩过程。

Singleton removal（奇异点清除） 假设一个巨大的素数 $p$ 在数亿个关系中“仅仅出现了一次”。因为我们的目标是“让所有素数的指数都变为偶数（2的倍数）”，所以只出现一次的素数是绝对无法变成偶数的。因此，包含该素数的关系会被视为“无用的垃圾”立即删除（清除）。由于这会引起连锁反应，原本数亿行的数据会迅速减少。
Clique merging（团合并） 进一步地，将共享特定素数的关系互相相乘（相加），从而在减少行数的同时，把稀疏（空洞多）的矩阵压缩成更稠密的状态（使用类似图论中的团搜索技术）。

通过这种优化，巨大的稀疏矩阵被戏剧性地压缩到了可以计算的规模。

6. Phase 4: GF(2) 上的线性代数（Block Wiedemann法）

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // 迭代进行稀疏矩阵与向量的乘积运算，
 // 找到多个满足 M * x = 0 mod 2 的解向量(零空间)。
 }
};

终于到了拼图的核心。将收集到的关系相乘，寻找 “所有素因子的指数都变成偶数次方的组合”。

这在数学上等同于，用一个元素为各素数指数的“偶数/奇数（即0或1）”的巨大矩阵 $M$，和一个表示使用哪些关系的向量 $x$，求解满足 $M \cdot x \equiv 0 \pmod 2$ 的解向量 $x$（零空间、核）。

我们需要解开数百万行 × 数百万列这种惊人规模矩阵的联立方程式。如果使用普通的高斯消元法，计算复杂度将达到 $O(N^3)$，即使到宇宙终结也算不完。

因此，最尖端的实现采用了 “Block Wiedemann（分块维德曼）法”。这是一种Krylov子空间法，利用矩阵 $M$ “非常稀疏（几乎全是0）”的特点，通过迭代进行矩阵与向量的乘法运算来推导出解。与传统的Block Lanczos法不同，Block Wiedemann法可以将计算过程完全分割给多个集群，因此在现代的分布式云计算或超级计算机的并行计算中能发挥压倒性的威力。

7. Phase 5: 代数平方根（Algebraic Square Root）与密码的崩溃

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. 有理侧平方根 V 的计算
 cpp_int V = 1;

 // 2. 代数侧平方根 gamma 的计算
 cpp_int Y = 1;

 // ...
 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)
 }
};

通过Phase 4的矩阵计算，我们得到了“一旦相乘，所有素因子都会变为偶数次方的关系集合 $S$”。借此，我们能够在有理侧和代数侧各自的世界中构建出“平方”。

有理侧只是简单的整数乘法，计算平方根 $V$ 很容易。

$$V^2 = \prod_{S} (a - bm)$$

然而，真正的地狱在于“代数侧”。 在代数域的世界 $\mathbb{Z}[\alpha]$ 中，素因子分解的唯一性不成立，因此我们一直使用理想（Ideal）进行计算。矩阵计算所保证的仅仅是 “成为了理想的平方”，而并未保证“成为元素的平方（$\gamma^2$）”。

在此，代数数论中两堵坚固的高墙——“理想类群的障碍”与“单位群的障碍”——拦住了去路。在GNFS中，为了打破这堵墙，使用了 “二次剩余特征（Quadratic Characters）” 这种魔法。即在Phase 4的矩阵中，事先悄悄加入了针对数十个特定素理想的二次剩余（勒让德符号）列。这样一来，找到的集合 $S$ 就能以压倒性的概率绕过障碍，顺利形成“真正的元素平方 $\gamma^2$”。

求 $\gamma$ 的过程（代数平方根）使用了如Montgomery法等极其复杂的算法。

最后，通过环同态映射 $\phi$（将 $x$ 替换为 $m$），把代数侧的平方根 $\gamma$ 传送回现实世界，得到 $Y$。只要将有理侧的 $V$ 直接作为 $X$，我们一直追求的绝对等式便终于完成了。

$$X^2 \equiv Y^2 \pmod N$$

剩下的就只是计算 $\gcd(X-Y, N)$ 了。经过0.001秒的短暂运算，当非平凡因子打印在屏幕上的那一刻，曾被认为坚不可摧的RSA加密便彻底崩溃了。

结语

GNFS绝非仅仅是编程技巧。它是将抽象代数、环论、理想类群等“纯数学的深渊”，用超级计算机的分布式架构和缓存优化等“极限工程学”加以征服后的人类智慧结晶。

我们平日里漫不经心发送的聊天信息或信用卡数据，正是被建立在这种天文级别的数学攻防之上的系统所保护着。

希望通过这个C++框架，能让您感受到最尖端密码破解算法背后蕴藏的“数学与计算机的浪漫”。

如何从 C++ 调用 Microsoft.Windows.AI

Sat, 19 Jul 2025 10:03:51 +0900

🎯 如何从 C++ 调用 `Microsoft.Windows.AI`【附示例代码】

自 Windows 10 起，Windows 标准配备了 **可以运行 ONNX 格式 AI 模型的运行时 。这就是 ** Windows ML (Windows.AI.MachineLearning)。

本文将 通过示例代码详细讲解 ** 如何从 ** C++（基于 Win32 应用程序） 调用 Microsoft.Windows.AI.MachineLearning。

✅ 准备篇

◾ 必备环境

Windows 10 (1809+) 或 Windows 11
Visual Studio 2019 及以上版本（Community 版即可）
C++/WinRT 支持 (Microsoft.Windows.CppWinRT)
Windows SDK 10.0.17763.0 及以上

✅ 项目配置

在 Visual Studio 中创建一个如下配置的项目。

类型：C++ Windows 桌面应用程序（空项目）
子系统：Windows（WinMain）
通过 NuGet 添加以下包
1

Microsoft.Windows.CppWinRT

✅ 示例代码

以下是使用 WinMain 结合 Win32 API 和 Windows.AI.MachineLearning 的最小配置示例。

※ 假设使用的 ONNX 模型为 model.onnx，请将其放置在与可执行文件相同的文件夹中。

`main.cpp`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <windows.h>
#include <winrt/Windows.AI.MachineLearning.h>
#include <winrt/Windows.Storage.h>

#pragma comment(lib, "windowsapp") // 用于 WinRT 链接

using namespace winrt;
using namespace Windows::AI::MachineLearning;
using namespace Windows::Storage;

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
 // WinRT 初始化（MTA 或 STA 均可）
 winrt::init_apartment();

 try {
 // 加载模型文件
 auto modelFile = StorageFile::GetFileFromPathAsync(L"model.onnx").get();
 LearningModel model = LearningModel::LoadFromStorageFileAsync(modelFile).get();

 // 创建会话
 LearningModelSession session(model);
 LearningModelBinding binding(session);

 // 模型的输入输出（这里暂时为空输入）
 // 实际上需要使用 TensorFloat 等进行绑定

 // 执行推理
 auto result = session.EvaluateAsync(binding, L"").get();

 MessageBox(nullptr, L"推理已完成", L"Windows ML (C++)", MB_OK);
 }
 catch (winrt::hresult_error const& ex) {
 MessageBox(nullptr, ex.message().c_str(), L"错误", MB_ICONERROR);
 }

 return 0;
}

✅ 补充：输入与输出 Tensor 的指定方法

根据模型的不同，在推理前可能需要 创建并绑定 Tensor。

示例：

1
2
3
4
5
6
7
8


// 将一维 float 数组转换为 Tensor
std::vector<float> inputData = {0.5f, 0.3f, 0.2f};
std::vector<int64_t> shape = {1, 3}; // 形状：[1, 3]

auto tensor = TensorFloat::CreateFromArray(shape, inputData);

// 输入绑定（与模型的输入名一致）
binding.Bind(L"input_0", tensor);

输出也一样，可以通过 result.Outputs().Lookup(L"output_0") 获取。

✅ 调试注意事项

如果模型文件不在运行文件夹中，会抛出 FileNotFoundException。
如果输入输出名称不匹配，会导致 invalid_argument 错误。
模型的准确 I/O 规范可以使用 Netron 等工具确认。

✅ 总结

项目	内容
使用API	Windows.AI.MachineLearning (WinRT)
语言	C++（基于 Win32）
推荐方法	通过 C++/WinRT 头文件
优点	原生运行 ONNX 模型，也支持 GPU
注意	注意模型的输入名称和 Tensor 形状

✅ 替代方案：写给不想使用 WinRT 的人

如果使用 Microsoft 提供的 ONNX Runtime，就可以 在完全不使用 WinRT 的情况下从 C++ 处理 ONNX 模型。
它支持跨平台，在 Windows/Linux 上也可以使用通用代码。

📌 结语

Windows ML (Microsoft.Windows.AI) 是一款强大的 AI 推理引擎，即使在 C++ 中也能很好地使用。如果您需要在 Windows 原生环境中进行推理，请务必尝试一下。

如果您需要创建 ONNX 模型或 Tensor 绑定的具体示例，我们将会在后续文章中进行讲解！

从 C++ 调用 TinyLLaMA 的步骤（使用 llama.cpp）

Sat, 19 Jul 2025 09:40:53 +0900

✅ TinyLLaMA × C++ 设置步骤（使用 `llama.cpp`）

🔧 Step 1: 准备 llama.cpp

1-1. 运行环境（最低要求）

OS: Windows / Linux / macOS
开发环境: g++ / clang / MSVC
Git / CMake

1-2. 获取并构建 llama.cpp

1
2
3
4
5
6


git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build
cd build
cmake ..
cmake --build . --config Release

如果是 Windows 系统，在 Visual Studio Developer Command Prompt 中使用 cmake --build . --config Release 会更方便。

📦 Step 2: 下载并转换 TinyLLaMA 模型

2-1. 从 HuggingFace 获取原模型

示例: TinyLLaMA-1.1B

1
2
3
4
5
6
7


# 根据需要使用 transformers 进行下载
pip install transformers huggingface_hub

python3 -m transformers.models.llama.convert_llama_weights_to_hf \
 --input_dir ./TinyLlama-1.1B-Chat \
 --model_size 1B \
 --output_dir ./hf_model

这是转换为 Hugging Face 格式的步骤。

2-2. 转换为 GGUF 格式（供 `llama.cpp` 使用）

1
2


cd llama.cpp
python3 convert.py ./hf_model --outfile tinyllama.gguf

2-3. 模型量化（减小体积）

1

./quantize ./tinyllama.gguf ./tinyllama-q4.gguf q4_0

q4_0 是 4bit 量化。模型大小将缩小至约 350MB左右。

🧪 Step 3: 从 C++ 调用模型（代码示例）

3-1. 简单的 C++ 代码（推理）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


#include "llama.h"
#include <iostream>

int main() {
 llama_model_params model_params = llama_model_default_params();
 llama_context_params ctx_params = llama_context_default_params();

 llama_model *model = llama_load_model_from_file("tinyllama-q4.gguf", model_params);
 llama_context *ctx = llama_new_context_with_model(model, ctx_params);

 std::string prompt = "用户说想读取Excel数据、进行过滤并保存。节点结构是怎样的？";
 llama_batch batch = llama_batch_init(512, 0, 1);
 llama_token BOS = llama_token_bos(model);
 batch.token[0] = BOS;

 // 词法分析 (Tokenize)
 std::vector<llama_token> tokens(prompt.size() + 8);
 int n = llama_tokenize(model, prompt.c_str(), tokens.data(), tokens.size(), true);
 tokens.resize(n);

 for (size_t i = 0; i < tokens.size(); ++i) {
 batch.token[i + 1] = tokens[i];
 }

 batch.n_tokens = tokens.size() + 1;
 llama_decode(ctx, batch);

 // 获取推理结果
 for (int i = 0; i < 50; ++i) {
 llama_token next = llama_sample_token(ctx, nullptr);
 std::cout << llama_token_to_str(model, next);
 llama_batch next_batch = llama_batch_init(1, 0, 1);
 next_batch.token[0] = next;
 next_batch.n_tokens = 1;
 llama_decode(ctx, next_batch);
 }

 llama_free(ctx);
 llama_free_model(model);
 return 0;
}

🧱 Step 4: 编译方法（示例）

1

g++ -I./llama.cpp main.cpp ./llama.cpp/build/libllama.a -o tiny_infer -pthread -std=c++11

libllama.a 将在构建后生成于 build/ 目录中。

✅ 产物结构示例（整理）

1
2
3
4
5
6


my_app/
├── tinyllama-q4.gguf # 已量化模型 (~350MB)
├── main.cpp # 上述 C++ 代码
├── llama.cpp/ # llama.cpp 本体
└── build/
 └── libllama.a # 已编译库

🧠 适用于用例的补充说明

在 C++ 中编写接收输出并 匹配和选择节点模板 的代码
示例：包含“Excel”、“过滤”、“保存” → 生成对应的节点组
这部分使用诸如 if 语句 + JSON 模板读取 的简单结构即可

📌 总结

项目	内容
推荐模型	TinyLLaMA-1.1B-Chat v1.0（GGUF + 量化）
大小	～350〜450MB（4bit量化）
C++集成	可以使用 `llama.cpp`，几乎没有外部依赖
处理能力	足以满足简单的意图理解和输出文本生成（自然语言→结构）
可扩展性	结合槽位填充和模板调用，可构建节点生成AI

使用 Slack App + OAuth2 向 Slack 发布消息的方法

Wed, 16 Jul 2025 23:36:27 +0900

✅ 使用访问令牌的发布方法（Slack Web API）

Slack 的「OAuth Token（如 xoxb-〜）」是使用 Slack 的 Web API 进行发布的密钥。在这种情况下，与 Webhook 不同，它是向 Slack API 端点 发送带有 Authorization: Bearer 请求头的 POST 请求。

🔑 必要前提

在 Slack 应用中需要将 chat:write 包含在 OAuth 作用域（Scope）中：

设置步骤

访问 https://api.slack.com/apps
创建应用或选择现有应用
在「OAuth & Permissions」 > Scopes 中 → 添加 chat:write
点击「Install to Workspace」或「Reinstall」获取 Access Token（例如：xoxb-xxxxxxxxxx）

💻 C++ 代码（通过 WinHTTP 向 Slack API 发布消息）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


#include <windows.h>
#include <winhttp.h>
#include <iostream>

#pragma comment(lib, "winhttp.lib")

bool PostSlackMessage(const std::wstring& accessToken, const std::string& channel, const std::string& text) {
 const wchar_t* host = L"slack.com";
 const wchar_t* path = L"/api/chat.postMessage";

 HINTERNET hSession = WinHttpOpen(L"SlackPoster/1.0",
 WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 WINHTTP_NO_PROXY_NAME,
 WINHTTP_NO_PROXY_BYPASS, 0);
 if (!hSession) return false;

 HINTERNET hConnect = WinHttpConnect(hSession, host, INTERNET_DEFAULT_HTTPS_PORT, 0);
 if (!hConnect) return false;

 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"POST", path,
 NULL, WINHTTP_NO_REFERER,
 WINHTTP_DEFAULT_ACCEPT_TYPES,
 WINHTTP_FLAG_SECURE);

 // Authorization请求头和Content-Type
 std::wstring headers = L"Content-Type: application/json\r\n";
 headers += L"Authorization: Bearer " + accessToken + L"\r\n";

 // JSON请求体
 std::string body = R"({"channel":")" + channel + R"(","text":")" + text + R"("})";

 BOOL result = WinHttpSendRequest(hRequest,
 headers.c_str(),
 (DWORD)-1,
 (LPVOID)body.c_str(),
 body.length(),
 body.length(),
 0);

 if (!result || !WinHttpReceiveResponse(hRequest, NULL)) {
 std::cerr << "发送错误\n";
 return false;
 }

 // 检查状态码
 DWORD statusCode = 0;
 DWORD size = sizeof(statusCode);
 WinHttpQueryHeaders(hRequest,
 WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
 WINHTTP_HEADER_NAME_BY_INDEX,
 &statusCode, &size, WINHTTP_NO_HEADER_INDEX);

 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);

 return (statusCode == 200);
}

int main() {
 std::wstring token = L"xoxb-你的访问令牌"; // 访问令牌
 std::string channel = "频道ID或#general"; // 例如: "#general" 或 "C0123456789"
 std::string message = "尝试从C++向Slack发布消息！";

 if (PostSlackMessage(token, channel, message)) {
 std::cout << "发布成功！\n";
 } else {
 std::cerr << "发布失败。\n";
 }

 return 0;
}

📌 获取频道ID的方法

仅使用频道名称（例如：#general）有时会导致错误。可靠的方法是使用 Slack 频道页面 URL 中的 ID。

1
2


https://app.slack.com/client/Txxxxx/C0123456789
 ↑这部分就是频道ID

✅ 关于令牌种类（补充）

令牌格式	用途	示例
`xoxb-...`	Bot Token（推荐）	发布・编辑・删除
`xoxp-...`	User Token（不推荐）	非Bot类的操作
Refresh Token	用于长期令牌更新	通常不使用

📝 总结

要从 C++ 向 Slack 发布消息，Slack Web API + Bearer Token 方式是最可靠的
通过 HTTPS POST 使用 chat.postMessage 端点
令牌必须在 Bearer 请求头中发送
频道最好通过 指定ID 来确保准确无误

如何使用 C++（Win32 API + WinHTTP）向 Slack 发布消息【支持 Webhook】

Wed, 16 Jul 2025 19:42:56 +0900

如何使用 C++（Win32 API + WinHTTP）向 Slack 发布消息【支持 Webhook】

想从 C++ 向 Slack 发布消息。在 Node.js 或 Python 中很常见，但是使用「C++ × Win32 API × WinHTTP」的情况却很少见，对吧？

在本文中，我将 通过分步图文并茂的方式，简单易懂地讲解如何使用 Webhook URL 从 C++ 向 Slack 发送消息。

✅ 整体流程

要发布到 Slack，需要执行以下步骤。

获取 Slack 的 Webhook URL（API 密钥）
使用 WinHTTP 发送 POST 请求
以 JSON 格式构建消息正文
检查结果并完成！

🔑 Step1：如何获取 Slack Webhook URL

在 Slack 中，通过使用 Incoming Webhooks 功能，可以轻松地从外部服务发布消息。

获取步骤

访问 https://api.slack.com/apps
点击 Create New App
选择 From scratch，输入应用名称并选择发布目标工作区
从左侧菜单中选择“Incoming Webhooks”并启用它
点击“Add New Webhook to Workspace”并选择一个频道
复制生成的 URL（例如：https://hooks.slack.com/services/xxx/yyy/zzz）

该 URL 的作用类似于 API 密钥。

💻 Step2：使用 C++ 代码向 Slack 发送消息

使用的技术

Win32 API
WinHTTP（标准库）
JSON 格式的消息

示例代码（发布到 Slack）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82


#include <windows.h>
#include <winhttp.h>
#include <iostream>

#pragma comment(lib, "winhttp.lib")

bool PostToSlack(const std::wstring& webhookUrl, const std::string& messageJson) {
 // 解析 URL
 URL_COMPONENTS urlComp{};
 wchar_t hostName[256];
 wchar_t urlPath[1024];

 urlComp.dwStructSize = sizeof(urlComp);
 urlComp.lpszHostName = hostName;
 urlComp.dwHostNameLength = _countof(hostName);
 urlComp.lpszUrlPath = urlPath;
 urlComp.dwUrlPathLength = _countof(urlPath);

 if (!WinHttpCrackUrl(webhookUrl.c_str(), 0, 0, &urlComp)) {
 std::wcerr << L"URL解析失败\n";
 return false;
 }

 // 创建 HTTP 会话并连接
 HINTERNET hSession = WinHttpOpen(L"SlackPoster/1.0",
 WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 WINHTTP_NO_PROXY_NAME,
 WINHTTP_NO_PROXY_BYPASS, 0);
 HINTERNET hConnect = WinHttpConnect(hSession, hostName, urlComp.nPort, 0);
 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"POST", urlPath,
 NULL, WINHTTP_NO_REFERER,
 WINHTTP_DEFAULT_ACCEPT_TYPES,
 WINHTTP_FLAG_SECURE);

 std::wstring headers = L"Content-Type: application/json\r\n";
 BOOL result = WinHttpSendRequest(hRequest,
 headers.c_str(),
 -1,
 (LPVOID)messageJson.c_str(),
 messageJson.length(),
 messageJson.length(),
 0);

 if (!result) {
 std::cerr << "发送请求失败\n";
 return false;
 }

 WinHttpReceiveResponse(hRequest, NULL);

 DWORD statusCode = 0;
 DWORD size = sizeof(statusCode);
 WinHttpQueryHeaders(hRequest,
 WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
 WINHTTP_HEADER_NAME_BY_INDEX,
 &statusCode, &size, WINHTTP_NO_HEADER_INDEX);

 // 释放资源
 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);

 return (statusCode == 200);
}

int main() {
 std::wstring webhookUrl = L"https://hooks.slack.com/services/xxx/yyy/zzz"; // 请替换为您自己的 Webhook URL

 std::string message = R"({
 "text": "Hello from C++ :rocket:",
 "username": "C++ Bot",
 "icon_emoji": ":robot_face:"
 })";

 if (PostToSlack(webhookUrl, message)) {
 std::cout << "发布成功！\n";
 } else {
 std::cerr << "发布失败。\n";
 }

 return 0;
}

🧪 自定义 JSON 消息

Slack 的 Webhook 可以包含以下参数：

1
2
3
4
5
6


{
 "text": "通知内容",
 "username": "Bot名称",
 "icon_emoji": ":rocket:",
 "channel": "#任意频道名称"
}

📌 补充说明

Content-Type 必须指定为 "application/json"
Webhook URL 直接作为 wstring 传递（不需要 URL 编码）
由于是 HTTPS 通信，请不要忘记 WINHTTP_FLAG_SECURE

🎉 附录：Slack 中的发布确认示例

在 Slack 中显示如下：

1
2


[C++ Bot]
Hello from C++ :rocket:

✍️ 总结

项目	内容
发布方式	Webhook (Incoming Webhooks)
通信库	WinHTTP
数据格式	JSON
可用参数	text, username, icon_emoji, channel 等

即使您以前觉得使用 C++ 连接 Slack 有些困难，从今天起您也可以集成通知 Bot 了！

🚀 下期预告？

如果您感兴趣，下次：

文件附件
带按钮的 UI
Slack App + OAuth2 带来的灵活 API 操作

等，我们可以介绍更深入的 Slack 集成！

如何使用 C++ 向 Microsoft Teams 发送消息（WinHTTP + Graph API）

Mon, 14 Jul 2025 23:40:15 +0900

如何使用 C++ 向 Microsoft Teams 发送消息（WinHTTP + Graph API）

想自动向 Microsoft Teams 聊天发送消息吗？
这时候就可以使用 Microsoft Graph API。
本文将逐步介绍 使用 WinHTTP 的 C++ 代码示例 ** 以及 ** 所需的 API 认证步骤。

🔧 所需准备（Microsoft Graph API 认证设置）

1. 在 Azure 门户中注册应用

首先，要使用 Microsoft Graph API，需要在 Azure 中注册一个应用。

访问 Azure Portal
选择 「Microsoft Entra ID」 > 「＋添加」 > 「应用注册」 > 「新注册」
输入任意应用名称并点击「注册」

2. 添加 API 权限

进入左侧菜单「API 权限」
在 「Microsoft Graph」 > 「选择权限」 中搜索以下作用域并点击 「更新权限」

Chat.ReadWrite
User.Read

※ 如果想在频道（Channel）中发布消息，还需要 ChannelMessage.Send 权限

3. 记录客户端 ID 和租户 ID

记录显示在「概述」选项卡中的以下两项：

应用程序（客户端）ID
目录（租户）ID

4. 创建客户端密码（Client Secret）

进入「证书和密码」选项卡
选择「新客户端密码」 > 设置过期时间，然后点击「添加」
务必当场记录 显示的值（密码）

🔐 获取访问令牌（OAuth2）

获取令牌时使用 client_credentials 流程。
使用 curl 执行以下命令，获取访问令牌。

1
2
3
4
5
6
7


curl -X POST ^
 https://login.microsoftonline.com/{租户ID}/oauth2/v2.0/token ^
 -H "Content-Type: application/x-www-form-urlencoded" ^
 -d "client_id={客户端ID}" ^
 -d "scope=https%3A%2F%2Fgraph.microsoft.com%2F.default" ^
 -d "client_secret={客户端密码}" ^
 -d "grant_type=client_credentials"

响应示例

1
2
3
4
5
6


{
 "token_type":"Bearer",
 "expires_in":3599,
 "ext_expires_in":3599,
 "access_token": "eyJ0eXAiOiJKV1QiLCJub...（省略）"
}

使用此 access_token 来调用 Microsoft Graph API。

💬 向 Teams 聊天发布消息的 C++ 示例

以下是使用 WinHTTP 向聊天发布消息的 C++ 示例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <windows.h>
#include <winhttp.h>
#include <iostream>
#include <string>

#pragma comment(lib, "winhttp.lib")

void PostToTeamsChat(const std::wstring& accessToken, const std::wstring& chatId, const std::wstring& message) {
 HINTERNET hSession = WinHttpOpen(L"TeamsPoster/1.0", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);

 HINTERNET hConnect = WinHttpConnect(hSession, L"graph.microsoft.com", INTERNET_DEFAULT_HTTPS_PORT, 0);

 std::wstring endpoint = L"/v1.0/chats/" + chatId + L"/messages";
 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"POST", endpoint.c_str(), NULL,
 WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_SECURE);

 std::wstring jsonBody = L"{\"body\": {\"content\": \"" + message + L"\"}}";
 std::wstring headers = L"Authorization: Bearer " + accessToken + L"\r\nContent-Type: application/json\r\n";

 BOOL bResult = WinHttpSendRequest(hRequest,
 headers.c_str(), (DWORD)-1L,
 (LPVOID)jsonBody.c_str(), (DWORD)(jsonBody.length() * sizeof(wchar_t)),
 (DWORD)(jsonBody.length() * sizeof(wchar_t)), 0);

 if (bResult)
 WinHttpReceiveResponse(hRequest, NULL);

 DWORD dwSize = 0;
 WinHttpQueryDataAvailable(hRequest, &dwSize);

 if (dwSize > 0) {
 std::wstring response(dwSize / sizeof(wchar_t), 0);
 DWORD dwDownloaded = 0;
 WinHttpReadData(hRequest, &response[0], dwSize, &dwDownloaded);
 std::wcout << L"Response: " << response << std::endl;
 }

 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);
}

int main() {
 std::wstring access;
 std::wstring chatId = L"19:";
 std::wstring message = L"Hello from C++!";
 std::wcout << L"Enter your access token: ";
 std::getline(std::wcin, access);
 std::wcout << L"Enter chat ID: ";
 std::getline(std::wcin, chatId);
 PostToTeamsChat(access, chatId, message);
 return 0;
}

🔍 获取聊天 ID 的方法

可以通过 GET /v1.0/me/chats 来查看聊天 ID。

1
2
3
4


curl -X GET ^
 https://graph.microsoft.com/v1.0/me/chats ^
 -H "Authorization: Bearer {access_token}" ^
 -H "Content-Type: application/json"

响应示例

1
2
3
4
5
6
7
8
9


{
 "value": [
 {
 "id": "19:abc123xyz@thread.v2",
 "topic": null,
 "chatType": "oneOnOne"
 }
 ]
}

📌 注意事项

本示例仅为最基本实现。在实际应用中需注意：
- 令牌过期的处理
- HTTPS 证书的验证
- 增强错误处理
频道发布请使用 teams/{team-id}/channels/{channel-id}/messages。
发送附件需要多部分（multipart）处理或 Graph Drive API。

总结

📎 总结

功能	概要
Graph API	与 Teams 交互的官方 API
应用注册	在 Azure 上进行必要的认证手续
访问令牌	通过 OAuth2 获取，并用于请求中
C++ 实现	使用 WinHTTP 调用 Graph API

🚀 后续步骤

作为进一步的示例扩展，您还可以尝试以下内容：

团队频道发布 (/teams/{team-id}/channels/...)
带附件发布
切换机器人账号或用户账号
包含获取令牌的完整 C++ 实现

如果您有需要，欢迎随时留言！

使用 Win32API + C++ 编写程序的优缺点

Sat, 12 Jul 2025 12:30:35 +0900

使用 Win32API + C++ 开发的魅力与挑战

对于想要深入 Windows 应用开发的人来说，Win32API + C++ 至今依然是一个强大的选择。这种组合能够以最近的距离与操作系统交互，兼具高速性与灵活性。

另一方面，由于其与现代的开发风格大相径庭，因此在学习上需要做好心理准备。

本文将从 现役 Windows 应用开发者的视角，浅显易懂地解说其优点与缺点。

优点

超高速的原生执行

C++ 和 Win32API 在最靠近操作系统的层级上运行，因此几乎没有多余的开销。其 CPU 和内存的使用效率极高，拥有 压倒性的执行速度。

极高的灵活性和自由度

无论是窗口控制、异步处理、COM 协作还是进程管理等，应用的任何行为都可以 自行进行精细控制。你也可以构建专用于特定目的的工具，或自制独有的框架等。

无需运行时，便于分发

无需像 .NET 或 Java 那样的外部运行时，只需一个可执行文件即可分发。在再分发时不易出现问题，无需安装程序也能轻松运行，这是其魅力所在。

能够制作轻量级应用

由于只需最小限度的配置即可，其特征是 内存占用非常小。即使在低配置的 PC 或虚拟机环境中也能流畅运行。

支持操作系统级别的高级控制

鼠标与键盘的全局钩子、窗口样式的微调、系统菜单操作等，也能实现 在普通语言或库中难以完成的控制。

缺点

开发效率低

GUI 的构建也完全需要通过代码来实现，有时 仅制作一个按钮就需要几十行代码。更改设计时的修改也很繁琐，与使用 UI 框架的开发相比，生产力较低。

维护性容易下降

消息循环和窗口过程等 结构特殊的代码 很多，在可读性和可重用性上存在困难。也有不适合团队开发或长期维护的一面。

适配现代 UI 很麻烦

高 DPI 适配、触摸界面、无障碍功能、深色模式等，很难应对近年来对 UX（用户体验）的要求。必须逐一手动进行适配，非常费力。

不支持跨平台

因为完全是 Windows 专用的 API，无法移植到 macOS 或 Linux。如果考虑到多平台部署，则需要选择其他技术。

学习成本极高

必须理解句柄、GDI、COM、OLE 等 在现代已经不太使用的概念和机制。文档也有很多是旧的，学习需要时间和毅力。

适合的用途

文件启动器或快捷键辅助等 轻量级工具
剪贴板操作或 IME 控制等 系统实用程序
全局钩子或窗口捕获等 原生控制系应用
与硬件紧密协作的 驱动辅助工具

不适合的用途

重视现代 UI/UX 的 面向普通消费者的应用
速度优先的 原型制作或 MVP 开发
以长期运营或团队开发为前提的 大规模项目
需要支持多个操作系统的 跨平台产品

评价总结

维度	评价
执行速度	◎ 非常快
内存效率	◎ 优秀
开发速度	× 慢
维护性	× 低
跨平台支持	× 不支持
现代 UI 支持	× 弱
OS 控制自由度	◎ 压倒性地高

结论

Win32API + C++ 是适合“想要自己处理操作系统的一切”的开发者的工具。 虽然它的力量非常强大，但在学习和运用上也需要相应的心理准备。

是否有“特意去选择”的价值，取决于你目标应用的性质。

不依赖 GUI 框架或现代语言，跃入 #include <windows.h> 的世界—— 这种选择，至今依然是有意义的。

【面向初学者】使用vcpkg在Visual Studio中安装libcurl（支持OpenSSL）的步骤

Mon, 07 Jul 2025 21:46:08 +0900

在Visual Studio中使用libcurl（支持OpenSSL），推荐使用简单易用的vcpkg

在C++中处理HTTP通信时，经常会用到 libcurl。但是，构建和调整依赖关系往往出乎意料地麻烦。

这时候派上用场的就是微软出品的C++库管理工具“vcpkg”。这次，我们将介绍使用 vcpkg 安装 libcurl（支持OpenSSL），并在Visual Studio中顺畅使用的步骤。

安装vcpkg（仅限未安装的用户）

首先来安装 vcpkg。请在 PowerShell 中执行以下步骤。

1
2
3


git clone https://github.com/microsoft/vcpkg
cd vcpkg
.\bootstrap-vcpkg.bat

※如果尚未安装Git，请从Git官网进行安装。

安装libcurl（支持OpenSSL）

接下来，使用vcpkg安装 libcurl。要指定支持OpenSSL的64位版本，请执行以下命令：

1

vcpkg install curl[ssl] --triplet x64-windows

执行此命令后，所需的依赖项（如OpenSSL等）也会自动设置。

与Visual Studio的集成设置

为了在Visual Studio项目中方便地使用通过vcpkg安装的库，请使用以下命令进行集成设置。

1

vcpkg integrate install

进行此设置后，在Visual Studio项目中将自动可以使用 #include <curl/curl.h>，无需再手动配置库路径或链接器设置。

结语

至此，在Visual Studio中安装 libcurl（支持OpenSSL）的准备工作就完成了。

使用vcpkg，可以统一管理麻烦的依赖关系
通过 vcpkg install curl[ssl] --triplet x64-windows 轻松安装libcurl
通过 vcpkg integrate install 即可实现与Visual Studio的自动集成

接下来，只需在项目中包含头文件，并使用libcurl的API开始开发吧。充分利用方便的vcpkg，一口气提高开发效率吧。

通过 C++/CLI DLL 从 C++ 执行 PowerShell 的步骤

Wed, 16 Apr 2025 01:58:03 +0900

🎯 通过 C++/CLI DLL 从 C++ 执行 PowerShell 的步骤（Visual Studio 2022 / C++）

✅ 整体架构

🔹 ① CLI 包装 DLL (C++/CLI)

提供执行 PowerShell 脚本的功能。

🔹 ② 原生 C++ 调用方

调用 CLI DLL 以执行 PowerShell 脚本。

🔧 步骤 1：创建 CLI 包装 DLL 项目

1. 创建项目

[新建项目] → [C++] → CLR 类库 (.NET Framework)
名称：PowerShellWrapper

💡 如果未显示此模板，请安装“.NET 桌面开发”工作负载。

2. 添加 NuGet 包

右键单击项目 → [管理 NuGet 程序包]
搜索并安装 System.Management.Automation
（版本 5.x 或 7.x）

3. CLI 端代码实现

PowerShellWrapper.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#pragma once

using namespace System;

namespace PowerShellWrapper {
 public ref class PowerShellExecutor {
 public:
 String^ Execute(String^ script);
 };
}

PowerShellWrapper.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include "PowerShellWrapper.h"
using namespace System;
using namespace System::Management::Automation;
using namespace System::Collections::ObjectModel;

String^ PowerShellWrapper::PowerShellExecutor::Execute(String^ script)
{
 PowerShell^ ps = PowerShell::Create();
 ps->AddScript(script);
 Collection<PSObject^>^ results = ps->Invoke();

 System::Text::StringBuilder^ sb = gcnew System::Text::StringBuilder();
 for each (PSObject^ result in results)
 {
 sb->AppendLine(result->ToString());
 }

 return sb->ToString();
}

🔧 步骤 2：从原生 C++ 端调用

1. 创建 C++ 控制台应用项目

名称：NativeApp

2. 添加引用

右键单击项目 → [添加] → [引用] → [项目] → 添加 PowerShellWrapper
[配置属性] → [C/C++] → [常规] → [公共语言运行时支持] → 更改为 /clr

3. 执行代码 (main.cpp)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#using <System.dll>
#using "..\\PowerShellWrapper\\Debug\\PowerShellWrapper.dll"

using namespace System;
using namespace PowerShellWrapper;

int main()
{
 PowerShellExecutor^ executor = gcnew PowerShellExecutor();
 String^ result = executor->Execute("Get-Process | Select-Object -First 1");
 Console::WriteLine(result);
 return 0;
}

💡 补充说明（IDL / TLB / COM 注册）

由于此架构直接引用 .NET DLL 而不是 COM，因此 无需 IDL、TLB 或 COM 注册。

✅ 最终结构

1
2
3
4
5


Solution
├── PowerShellWrapper (C++/CLI DLL)
│ └── PowerShellExecutor
├── NativeApp (C++ EXE)
 └── main.cpp → DLL 调用

通过 C++/CLI DLL 从 C++ 执行 PowerShell 的步骤

Wed, 16 Apr 2025 01:58:03 +0900

🎯 通过 C++/CLI DLL 从 C++ 执行 PowerShell 的步骤（Visual Studio 2022 / C++）

✅ 整体架构

🔹 ① CLI 包装 DLL (C++/CLI)

提供执行 PowerShell 脚本的功能。

🔹 ② 原生 C++ 调用方

调用 CLI DLL 以执行 PowerShell 脚本。

🔧 步骤 1：创建 CLI 包装 DLL 项目

1. 创建项目

[新建项目] → [C++] → CLR 类库 (.NET Framework)
名称：PowerShellWrapper

💡 如果未显示此模板，请安装“.NET 桌面开发”工作负载。

2. 添加 NuGet 包

右键单击项目 → [管理 NuGet 程序包]
搜索并安装 System.Management.Automation
（版本 5.x 或 7.x）

3. CLI 端代码实现

PowerShellWrapper.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#pragma once

using namespace System;

namespace PowerShellWrapper {
 public ref class PowerShellExecutor {
 public:
 String^ Execute(String^ script);
 };
}

PowerShellWrapper.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include "PowerShellWrapper.h"
using namespace System;
using namespace System::Management::Automation;
using namespace System::Collections::ObjectModel;

String^ PowerShellWrapper::PowerShellExecutor::Execute(String^ script)
{
 PowerShell^ ps = PowerShell::Create();
 ps->AddScript(script);
 Collection<PSObject^>^ results = ps->Invoke();

 System::Text::StringBuilder^ sb = gcnew System::Text::StringBuilder();
 for each (PSObject^ result in results)
 {
 sb->AppendLine(result->ToString());
 }

 return sb->ToString();
}

🔧 步骤 2：从原生 C++ 端调用

1. 创建 C++ 控制台应用项目

名称：NativeApp

2. 添加引用

右键单击项目 → [添加] → [引用] → [项目] → 添加 PowerShellWrapper
[配置属性] → [C/C++] → [常规] → [公共语言运行时支持] → 更改为 /clr

3. 执行代码 (main.cpp)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#using <System.dll>
#using "..\\PowerShellWrapper\\Debug\\PowerShellWrapper.dll"

using namespace System;
using namespace PowerShellWrapper;

int main()
{
 PowerShellExecutor^ executor = gcnew PowerShellExecutor();
 String^ result = executor->Execute("Get-Process | Select-Object -First 1");
 Console::WriteLine(result);
 return 0;
}

💡 补充说明（IDL / TLB / COM 注册）

由于此架构直接引用 .NET DLL 而不是 COM，因此 无需 IDL、TLB 或 COM 注册。

✅ 最终结构

1
2
3
4
5


Solution
├── PowerShellWrapper (C++/CLI DLL)
│ └── PowerShellExecutor
├── NativeApp (C++ EXE)
 └── main.cpp → DLL 调用

如何在C++中以ISO8601格式输出当前时间

Sat, 15 Apr 2023 19:35:27 +0900

前提条件

ISO C++ 20 标准 (/std:c++20)

代码

1
2
3
4


#include <chrono>
#include <format>

std::string datetime = std::format("{:%FT%TZ}", system_clock::now());

以上就是如何在C++中以ISO8601格式输出当前时间的方法。

参考

std::format

在 Windows 上构建 OpenSSL 的方法

Fri, 07 Apr 2023 21:06:32 +0900

什么是 OpenSSL

它是一个提供加密通信必要处理的开源库。

要在程序中使用它，由于公开了 C 语言源代码，我们需要编译以创建库。

下面介绍构建步骤。

准备构建环境

Perl

从 https://strawberryperl.com/ 下载 strawberry-perl-5.32.1.1-64bit.msi。我认为最新版本就可以了。
NASM

从 https://www.nasm.us/ 的 Download 下载 2.16.01/nasm-2.16.01-win64.zip。我认为除了 rc 版本外的最新版本就可以了。安装后，需要将 NASM 安装的文件夹注册到环境变量 PATH 中。
Visual Studio 2022 ** 或 ** Build Tools for Visual Studio 2022

从 https://visualstudio.microsoft.com/ja/downloads/ 安装 Visual Studio 2022 Community 或 Build Tools for Visual Studio 2022。

Windows 下 OpenSSL 的构建步骤

从 https://www.openssl.org/source/ 下载并解压 openssl-3.1.0.tar.gz。如果无法解压，可以在命令提示符下执行 tar -xzf openssl-3.1.0.tar.gz。
以管理员权限 启动命令提示符
打开解压后的文件夹
执行以下命令 ※请根据安装的 Visual Studio 版本更改 Community 部分

1

"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvarsall.bat" x64

执行以下命令

1

perl Configure VC-WIN64A

执行以下命令（非常耗时）

1

nmake

执行以下命令（非常耗时）

1

nmake test

执行以下命令

1

nmake install

如果成功，OpenSSL 将安装在 C:\Program Files\OpenSSL。

完毕

参考

https://ja.wikipedia.org/wiki/OpenSSL

C++ on kenji.blog

【完全解剖】使用C++实现并理解最强密码破解算法「GNFS」

【完全解剖】使用C++实现并理解最强密码破解算法「GNFS」

1. GNFS 最尖端逻辑框架（完整源代码）

2. GNFS的最终目的： $X^2 \equiv Y^2 \pmod N$

3. Phase 1: 多项式选择（Polynomial Selection）

4. Phase 2: 特殊 $q$ 格筛选法（Special-q Lattice Sieving）

5. Phase 3: 过滤（Filtering）

6. Phase 4: GF(2) 上的线性代数（Block Wiedemann法）

7. Phase 5: 代数平方根（Algebraic Square Root）与密码的崩溃

结语

如何从 C++ 调用 Microsoft.Windows.AI

🎯 如何从 C++ 调用 Microsoft.Windows.AI【附示例代码】

✅ 准备篇

◾ 必备环境

✅ 项目配置

✅ 示例代码

main.cpp

✅ 补充：输入与输出 Tensor 的指定方法

✅ 调试注意事项

✅ 总结

✅ 替代方案：写给不想使用 WinRT 的人

📌 结语

从 C++ 调用 TinyLLaMA 的步骤（使用 llama.cpp）

✅ TinyLLaMA × C++ 设置步骤（使用 llama.cpp）

🔧 Step 1: 准备 llama.cpp

1-1. 运行环境（最低要求）

1-2. 获取并构建 llama.cpp

📦 Step 2: 下载并转换 TinyLLaMA 模型

2-1. 从 HuggingFace 获取原模型

2-2. 转换为 GGUF 格式（供 llama.cpp 使用）

2-3. 模型量化（减小体积）

🧪 Step 3: 从 C++ 调用模型（代码示例）

3-1. 简单的 C++ 代码（推理）

🧱 Step 4: 编译方法（示例）

✅ 产物结构示例（整理）

🧠 适用于用例的补充说明

📌 总结

使用 Slack App + OAuth2 向 Slack 发布消息的方法

✅ 使用访问令牌的发布方法（Slack Web API）

🔑 必要前提

设置步骤

💻 C++ 代码（通过 WinHTTP 向 Slack API 发布消息）

📌 获取频道ID的方法

✅ 关于令牌种类（补充）

📝 总结

如何使用 C++（Win32 API + WinHTTP）向 Slack 发布消息【支持 Webhook】

如何使用 C++（Win32 API + WinHTTP）向 Slack 发布消息【支持 Webhook】

✅ 整体流程

🔑 Step1：如何获取 Slack Webhook URL

获取步骤

💻 Step2：使用 C++ 代码向 Slack 发送消息

使用的技术

示例代码（发布到 Slack）

🧪 自定义 JSON 消息

📌 补充说明

🎉 附录：Slack 中的发布确认示例

✍️ 总结

🚀 下期预告？

如何使用 C++ 向 Microsoft Teams 发送消息（WinHTTP + Graph API）

如何使用 C++ 向 Microsoft Teams 发送消息（WinHTTP + Graph API）

🔧 所需准备（Microsoft Graph API 认证设置）

1. 在 Azure 门户中注册应用

2. 添加 API 权限

3. 记录客户端 ID 和租户 ID

4. 创建客户端密码（Client Secret）

🔐 获取访问令牌（OAuth2）

响应示例

💬 向 Teams 聊天发布消息的 C++ 示例

🔍 获取聊天 ID 的方法

响应示例

📌 注意事项

总结

📎 总结

🚀 后续步骤

使用 Win32API + C++ 编写程序的优缺点

使用 Win32API + C++ 开发的魅力与挑战

优点

超高速的原生执行

极高的灵活性和自由度

🎯 如何从 C++ 调用 `Microsoft.Windows.AI`【附示例代码】

`main.cpp`

✅ TinyLLaMA × C++ 设置步骤（使用 `llama.cpp`）

2-2. 转换为 GGUF 格式（供 `llama.cpp` 使用）