阅读视图

2025年6月5日 05:22

什么是 C 中的 `restrict`？

restrict 是 C99 引入的指针类型限定符。它告诉编译器，该指针在其生命周期内是访问其所指内存的唯一方式。

这使得编译器可以安全地进行优化，因为它可以假设没有指针别名 —— 即没有其他指针访问相同的内存。

语法示例：

void copy(int *restrict dst, const int *restrict src, size_t n);

优点：

启用更激进的编译器优化
提升在循环和内存密集型操作中的性能
明确表达开发者对指针用途的意图

没有使用 `restrict` 时：

void copy(int *dst, const int *src, size_t n);

没有 restrict，编译器必须假设 dst 和 src 可能指向重叠的内存，限制了优化空间。

注意事项：

restrict 仅在 C99 及以上版本中有效
只适用于指针类型
错误使用会导致未定义行为

C++ 中有 `restrict` 吗？

C++ 并不包含 restrict 这一标准关键字。不过，可以通过其他方式实现类似效果。

1. 编译器扩展

大多数主流编译器支持非标准的替代写法，例如：

void foo(int* __restrict__ a, int* __restrict__ b);

GCC/Clang：__restrict__
MSVC：__restrict

注意：这些方式不具可移植性。

2. 使用现代 C++ 提供的更安全语义

现代 C++ 鼓励使用更安全、更清晰的方式，如：

使用引用而非原始指针
使用 std::span（C++20）明确表达内存范围

void add(std::span<int> dst, std::span<const int> src);

虽然这不能从底层强制无别名，但能提高代码意图的清晰度，有助于规避别名相关的问题。

总结对比表

功能	C语言	C++
`restrict` 支持	标准（C99+）	非标准
优化收益	支持	支持（需扩展）
更安全的替代方案	无	`std::span`、引用

总结

在 C 中，当你能确保没有内存别名并且关心性能时，应当使用 restrict。在 C++ 中，优先使用更现代的语义（如引用、std::span），必要时也可以谨慎使用编译器扩展版本的 __restrict__。

C/C++编程

英文：C vs C++: Understanding the restrict Keyword and its Role in Optimization

本文一共 460 个汉字, 你数一下对不对.

C与C++: restrict关键字及其在编译器优化中的作用. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c C与C++: restrict关键字及其在编译器优化中的作用 C++ C++ 学习笔记程序设计编程计算机

The post C与C++: restrict关键字及其在编译器优化中的作用 first appeared on 小赖子的英国生活和资讯.

用trae编程

郑永博客

作者郑永

2025年5月31日 11:13

trae西班牙语里是带来的意思，想买专业版，点击链接居然显示所在地区买不了，有钱都不赚吗？

所以最近一直在用免费版，里面有最新的claude 4 sonnet，编程非常强悍。

之前用trae速度很快，最近需要排队，而且排队有时候都有100多位，所以只能等。

之前以为这排队是因为很多人在用，于是在考虑人夜深人静的时候用，但发现也一样，我在想，难道他们在睡觉的时候也在给ai自动发送编程任务，所以不管什么时候，都会排队了。

这和ai编程的初衷有点吻合，就是你直接说，他帮你做，你喝完咖啡的功夫他就帮你写好了。

可我偏偏就是使劲的问个不停，马不停蹄，感觉自己还是很忙。

这不，现在多了个排队，你不得不喝咖啡等了，好像突然变得轻松起来了，虽然刚开始嫌他慢，但我发现这是不是变相在帮我放慢脚步，解放双手，因为我现在懒得写代码了，感觉写出来也没有ai写得好，这个排队就看作是给对方时间做。

我之前觉得自己做完就不用再写了，但没想到我以后可能得天天更新功能，就是后期维护，时不时的有人提出建议，你就要跟进，所以我会一直用这个ai工具维护代码，而且不用很累，我只要和我的代码团队（ai）交流即可，吩咐它写代码并检验，这就是我日后要做的事情。

本文完。

赏

转载请注明：https://xptt.com 用trae编程

C++的左值/lvalue, 右值/rvalue和右值引用/rvalue references

小赖子

2025年5月30日 06:13

C++ 左值（lvalue）、右值（rvalue）与右值引用（rvalue reference）

理解 C++ 中的左值、右值及其引用形式，是掌握现代 C++（尤其是 C++11 以后的移动语义/move和完美转发/perfect forwarding）必不可少的基础。

📌 什么是左值（lvalue）

左值指的是有名字、可寻址的对象，通常可以出现在赋值语句的左侧。

int x = 10;
x = 20;        // x 是左值
int* p = &x;   // 可以取地址

📌 什么是右值（rvalue）

右值是临时对象，不能被取地址，通常是表达式的结果或字面值常量。

int x = 10;
int y = x + 5;  // x + 5 是右值
y = 100;        // 100 是右值

右值不能出现在赋值语句左侧，且生命周期通常较短。

📌 右值引用（rvalue reference）

C++ 11 引入了右值引用（通过 && 语法），允许我们“捕获”右值。这为移动语义提供了基础。

void process(int& x);   // 左值引用
void process(int&& x);  // 右值引用

int main() {
    int a = 42;
    process(a);        // 调用 int&
    process(10);       // 调用 int&&
}

右值引用通常与移动构造函数、移动赋值运算符、std::move 和完美转发/forwarding一起使用。

📊 左值 vs 右值比较

特性	左值（lvalue）	右值（rvalue）
是否有名称	有	通常没有
是否可取地址	可以	不可以
是否可出现在赋值语句左侧	可以	不可以
生命周期	受作用域控制	通常是临时的
是否可绑定到 `&&`	否	是

🧪 std::move 与移动语义

std::string a = "hello";
std::string b = std::move(a);  // a 被“移”给了 b

std::move 并不移动对象，它只是把左值强制转换为右值，从而触发移动构造函数或移动赋值运算符。

💡 使用建议

使用左值引用（&）：
- 当你需要访问和修改已有变量
- 不涉及资源转移
使用右值引用（&&）：
- 希望接管临时对象的资源
- 编写移动构造函数或移动赋值
- 优化性能，避免深拷贝

总结

左值和右值是 C++ 表达式语义的核心。右值引用是现代 C++ 的重要特性，能显著提高资源管理和性能表现。理解它们的区别和用法，是成为高阶 C++ 程序员的基础。

C/C++编程

英文：C++ Lvalue, Rvalue and Rvalue References

本文一共 541 个汉字, 你数一下对不对.

C++的左值/lvalue, 右值/rvalue和右值引用/rvalue references. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c C++的左值/lvalue, 右值/rvalue和右值引用/rvalue references C++ C++ 学习笔记折腾程序设计编程计算机

The post C++的左值/lvalue, 右值/rvalue和右值引用/rvalue references first appeared on 小赖子的英国生活和资讯.

C++中的assert和static_assert的区别

小赖子

2025年5月29日 05:37

C++ `assert` 与 `static_assert` 的区别

C++ 提供了两种机制来验证程序中的假设（断言）：assert 和 static_assert。虽然它们看起来类似，但它们在不同的阶段工作，并且用途也不同。

🔍 assert — 运行时检查/断言

assert 用于在程序运行时验证条件是否成立。如果条件为假，程序会打印错误信息并中止运行。

#include <cassert>

int divide(int x, int y) {
    assert(y != 0);  // 如果 y 为 0，程序会中止
    return x / y;
}

assert 通常只在调试模式下启用，如果定义了 NDEBUG，这些断言会被禁用。

🧱 static_assert — 编译时检查/静态断言

static_assert 在编译期间检查条件是否成立。如果条件不满足，编译器会直接报错，阻止程序编译。

static_assert(sizeof(int) == 4, "此代码假设 int 是 4 字节");

它要求条件是一个常量表达式，特别适合在模板、类型检查或平台限制中使用。

📊 对比表

特性	`assert`	`static_assert`
检查时机	运行时	编译时
是否可被禁用	可以（通过 `NDEBUG`）	不可以
是否需要常量表达式	不需要	需要
失败时表现	程序中止	编译失败
主要用途	调试时的逻辑检查	编译时的类型或平台验证

💡 使用建议

适合使用 assert 的场景：
- 检查运行时数据或逻辑
- 验证函数参数或程序状态
- 只在调试模式下需要检查
适合使用 static_assert 的场景：
- 验证类型或大小是否符合要求
- 确保模板参数使用正确
- 编译时需要强制保证某些条件

总结

assert 和 static_assert 都能帮助你更早地发现程序中的问题，但它们发生的时间点不同。static_assert 更适合在编译阶段做静态验证，而 assert 更适合在调试阶段检查运行时逻辑。

C/C++编程

英文：C++ assert vs static_assert

本文一共 479 个汉字, 你数一下对不对.

C++中的assert和static_assert的区别. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c C++中的assert和static_assert的区别 C++ C++ 学习笔记折腾程序设计计算机

The post C++中的assert和static_assert的区别 first appeared on 小赖子的英国生活和资讯.

C++: auto_ptr智能指针被弃用

小赖子

2025年5月28日 03:03

为什么 `auto_ptr` 在 C++ 中被弃用

TLDR; 很久之前看到auto_ptr就觉得挺好，和auto一样，反正不用自己管，C++会自动推导智能指针的类型。不过这个关键字已经在C++ 11中被弃用/deprecated。

弃用与移除

std::auto_ptr 在 C++ 11 中被弃用。
在 C++ 17 中被完全移除。

为什么 `auto_ptr` 被弃用？

它具有不安全的拷贝语义/copy semantics。
拷贝一个 auto_ptr 会转移所有权，并将原指针设为 nullptr。
这种行为很容易引发 bug，尤其是在标准容器或算法中使用时。

<code>std::auto_ptr<int> p1(new int(42));
std::auto_ptr<int> p2 = p1; // 所有权被转移
std::cout << *p2 << std::endl; // 正常
std::cout << *p1 << std::endl; // 未定义行为（p1 变成 nullptr）
</code>

应该使用什么替代？

std::unique_ptr —— 独占所有权
std::shared_ptr —— 共享所有权

<code>#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> p1(new int(42));
    std::unique_ptr<int> p2 = std::move(p1); // 转移所有权
    std::cout << *p2 << std::endl;
}
</code>

对比表

特性	`std::auto_ptr`	`std::unique_ptr`
可拷贝性	是（但不安全）	否
移动语义	否	是
引入/移除	C++98 / C++17 中移除	C++11 引入

结论

在现代 C++ 中，使用 std::unique_ptr 或 std::shared_ptr 进行内存管理。不要在新的项目中再使用 auto_ptr。

C/C++编程

英文：Why auto_ptr is Deprecated in C++?

本文一共 236 个汉字, 你数一下对不对.

C++: auto_ptr智能指针被弃用. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c C++: auto_ptr智能指针被弃用 C++ C++ 学习笔记程序设计编程

The post C++: auto_ptr智能指针被弃用 first appeared on 小赖子的英国生活和资讯.

C++中的consteval是什么? 它与const和constexpr有何不同?

小赖子

C++ What is the consteval? How is it different to const and constexpr?

2025年5月25日 02:34

C++：什么是 `consteval`？它与 `const` 和 `constexpr` 有何不同？

如果你在 C++ 中经常使用 const 和 constexpr，可能会好奇 C++20 新引入的 consteval 关键字到底是做什么用的。下面我们来一一解析。

什么是 `consteval`？

consteval 用于声明一个立即函数（immediate function），也就是说，这个函数必须在编译期进行求值。与 constexpr 不同，constexpr 允许函数在编译期或运行期执行，而 consteval 强制要求只能在编译期调用。

consteval int square(int x) {
    return x * x;
}

如果尝试使用运行时参数调用此函数，将会导致编译错误。

示例

consteval int add(int a, int b) {
    return a + b;
}

int main() {
    constexpr int result = add(2, 3);  // 正确，编译期求值
    int x = 5;
    // int y = add(x, 3);  // 错误：add 必须在编译期调用
}

比较表

特性	`const`	`constexpr`	`consteval`
引入版本	C++11 之前	C++11	C++20
用途	声明只读变量	允许编译期求值	强制编译期求值
可用于	变量	变量、函数、构造函数	函数
是否可在运行期执行？	是	可能	否
是否强制编译期？	否	可选	是

什么时候该使用 `consteval`？

当你需要强制函数只能在编译期执行时。
用于元编程中，在编译期验证输入的正确性。
避免任何运行时开销。

高级用法示例：编译期字符串长度计算

consteval std::size_t const_strlen(const char* str) {
    std::size_t len = 0;
    while (str[len] != '\0') ++len;
    return len;
}

constexpr auto len = const_strlen("Hello");  // 正确，编译期求值

总结

consteval 是 C++ 中用于强制编译期执行的新利器。当你觉得 constexpr 不够严格时，它是实现严格编译期逻辑的最佳选择。

C/C++编程

本文一共 371 个汉字, 你数一下对不对.

C++中的consteval是什么? 它与const和constexpr有何不同?. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c C++中的consteval是什么? 它与const和constexpr有何不同? C++ C++ 学习笔记程序设计计算机

The post C++中的consteval是什么? 它与const和constexpr有何不同? first appeared on 小赖子的英国生活和资讯.

C++ 教程: 用std::move来移动所有权

小赖子

2025年5月19日 05:29

📘 C++ 移动语义与 std::move() 教程

C++的std::move用于转移变量/对像的所有权/Ownership。

🔹 什么是移动语义？

在 C++ 中，移动语义通过转移资源所有权/Ownership（如内存或文件句柄）来优化性能，而不是复制它们。

移动语义是在 C++11 中引入的，它允许：

更快速地传递大型或昂贵的对象
更高效地使用临时值

🔹 什么是 std::move()？

std::move(x) 并不会真的移动任何东西 —— 它只是将 x 转换为一个 右值引用（即 T&&），告诉编译器：
“你可以把这个对象当作临时对象来处理并移动它。”

要真正实现移动，你的类型必须实现 移动构造函数 或 移动赋值运算符。

✅ 什么时候该用 std::move()？

在以下情况下使用它：

你想 转移资源的所有权。
你正在处理 复制开销大的对象（如 std::string、std::vector、unique_ptr）。
你写的函数按值接收参数，并希望将其移动进成员变量。

🔍 std::string 示例

#include <iostream>
#include <string>
#include <utility>
int main() {
    std::string a = "hello";
    std::string b = std::move(a);
    std::cout << "b: " << b << std::endl;
    std::cout << "a: " << a << std::endl;
}

🔍 移动 std::vector

std::vector<int> original = {1, 2, 3};
std::vector<int> moved_to = std::move(original);
// original 现在为空（但仍然有效）

⚠️ 移动后会发生什么？

移动后：

被移动的对象 仍然有效。
但其 内容未定义 —— 你只能销毁它或重新赋值。

std::string x = "abc";
std::string y = std::move(x);
// x 现在处于有效但未定义的状态 —— 不要再读取它！

🧠 对内建类型使用 std::move()

int x = 42;
int y = std::move(x);  // 实际是拷贝，因为 int 没有移动语义

这没必要，因为像 int 这样的基本类型不支持移动构造。

🛠️ 自定义类型实现移动语义

class MyBuffer {
    int* data;
    size_t size;
public:
    MyBuffer(size_t s) : size(s), data(new int[s]) {}
    // 移动构造函数
    MyBuffer(MyBuffer&& other) noexcept
        : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }

    // 移动赋值运算符
    MyBuffer& operator=(MyBuffer&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
    ~MyBuffer() { delete[] data; }
};

使用示例：

MyBuffer a(1000);
MyBuffer b = std::move(a);  // 将 a 移动到 b

📦 std::move() 与智能指针

可以用 std::move来操作智能指针，比如 unique_ptr 或 shared_ptr：

#include <memory>
std::unique_ptr<int> p1 = std::make_unique<int>(10);
std::unique_ptr<int> p2 = std::move(p1);
// p1 现在为空指针

🔁 std::shared_ptr 所有权转移

当你“转移所有权”给另一个 shared_ptr 时，你实际上是：

将控制块（用于跟踪引用计数）从一个 shared_ptr 移动到另一个。
原来的 shared_ptr 变为空（use_count() == 0）。
总体引用计数不变（仍为 1，除非还有其他共享所有者）。

✅ 示例：通过 std::move() 转移所有权

#include <iostream>
#include <memory>
int main() {
    std::shared_ptr<int> p1 = std::make_shared<int>(42);
    std::cout << "p1 use_count: " << p1.use_count() << std::endl; // 1
    std::shared_ptr<int> p2 = std::move(p1); // 转移所有权
    std::cout << "p1 is " << (p1 ? "not null" : "null") << std::endl; // null
    std::cout << "p2 use_count: " << p2.use_count() << std::endl; // 1
}

🔍 重要区别：shared_ptr vs unique_ptr

指针类型	转移机制	允许拷贝	主要用途
`std::unique_ptr`	仅支持 `std::move()`	❌ 不允许	独占资源所有权
`std::shared_ptr`	`std::move()` 或拷贝	✅ 允许	共享资源所有权，引用计数

⚠️ 注意事项

你可以使用 move 来转移 shared_ptr 的所有权（源指针将变为空）。
你也可以拷贝 shared_ptr 来共享所有权（两个指针都有效，引用计数增加）。
只有在你明确希望原来的 shared_ptr 被置空时才使用 std::move()。

🔄 常见使用模式

函数返回值使用移动：

std::string get_name() {
    std::string name = "Alice";
    return std::move(name);
}

只有在你想强制进行移动（比如返回函数参数）时才使用 std::move()。

🚫 不该使用 std::move() 的场景

1. ❌ 不要从还需要使用的变量移动：

std::string s = "test";
std::string t = std::move(s);
std::cout << s;  // 内容未定义

2. ❌ 不要对 const 对象使用 std::move()：

const std::string s = "hi";
std::string t = std::move(s);  // 实际是拷贝，因为移动构造<a  href="https://justyy.com/archives/67736">函数</a>无法接收 const 参数

🧪 总结速查表

使用场景	是否使用 std::move()	原因
移动大型容器或字符串	✅ 是	高效转移内存或资源
移动智能指针	✅ 是	转移所有权
基本类型（如 int、bool）	🚫 否	没有移动语义，等同于拷贝
const 对象	🚫 否	移动构造函数不接受 const
临时变量	🚫 通常不需要	已经是右值了

✅ 最后小贴士

如果你不确定该不该用 std::move()，问自己：
“我是否不再需要这个变量并打算把它交出去？”
如果答案是“是” → 那就用 std::move()。

C/C++编程

英文：Tutorial on C++ std::move (Transfer Ownership)

本文一共 880 个汉字, 你数一下对不对.

C++ 教程: 用std::move来移动所有权. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c C++ 教程: 用std::move来移动所有权 C++ 学习笔记编程计算机

The post C++ 教程: 用std::move来移动所有权 first appeared on 小赖子的英国生活和资讯.

C++中的 const和constexpr 比较

小赖子

2025年5月17日 22:55

C++ `const` 与 `constexpr`：真正的区别是什么？

一眼看都是定义常量。

为什么这很重要

现代 C++ 鼓励编写不可变、高效且表达力强的代码。两个关键字—const 和 constexpr—是这一理念的核心。它们看起来很相似，但理解它们的不同语义，对于正确利用编译期与运行期行为至关重要。

高层次对比

特性	`const`	`constexpr`
编译期常量？	可能	一定（否则编译报错）
支持运行期？	支持	支持（在需要时运行期求值）
用于数组/模板参数？	仅当确实是常量	保证可用
允许函数？	仅限成员函数限定符	支持完整函数且可在编译期求值

1 声明不可变数据

`const`：构造后不可变

const int runtimeConst = std::rand(); // 是 const，但不是编译期常量

当你只想禁止变量被修改，而不在意值是在编译期还是运行期确定的，const 就足够了。

`constexpr`：必须在编译期已知

constexpr int arraySize = 10;
int arr[arraySize];           // 始终合法

如果值需要参与要求编译期常量的上下文（如数组大小、模板参数、switch 标签等），你必须使用 constexpr。

2 函数与方法

`const` 成员函数

class Widget {
public:
    int value() const {/*…*/} // 保证不会修改 this 对象
};

它保护对象状态，但不提供编译期求值能力。

`constexpr` 函数

constexpr int square(int n) { return n * n; }

static_assert(square(4) == 16, "编译期计算");

constexpr 函数在参数是常量表达式时可以在编译期执行，也可以在运行期使用。

3 常见陷阱

// 1. 编译通过：runtimeConst 只是 const
const int runtimeConst = std::rand();

// 2. 编译失败：std::rand() 不是 constexpr
constexpr int fails = std::rand();

记住：每个 constexpr 变量本质上都是 const，但并非所有 const 都是常量表达式。

4 如何选择

需要强制编译期计算？使用 constexpr
需要不可变性但值可能在运行期确定？使用 const
不确定时偏向使用 constexpr，编译器会提示你是否不合法

5 总结片段

constexpr int ctVal = 42; // 编译期常量
const int rtVal = std::rand(); // 运行期确定，但不可变

正确地选择 const 和 constexpr 能让你的 C++ 代码更安全、更高效、更具表达力。默认使用 constexpr，当且仅当你明确知道值只能在运行期获取时才使用 const。

C/C++编程

英文：const vs constexpr in C++

本文一共 525 个汉字, 你数一下对不对.

C++中的 const和constexpr 比较. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c C++中的 const和constexpr 比较 C++ C++ 学习笔记程序设计计算机

The post C++中的 const和constexpr 比较 first appeared on 小赖子的英国生活和资讯.

C++ Ranges 教程

小赖子

2025年5月17日 22:04

C++20 引入了 ranges（范围），这是一个强大且优雅的抽象，用于处理序列（如数组、vector 等）。相比传统的迭代器或旧式循环，Ranges 提高了代码的可读性、可组合性和性能。

什么是 Range？

在 C++20 中，range（范围） 是一种抽象，代表一个可以迭代的元素序列。它与 views（视图） 和 actions（操作） 如过滤、转换等配合使用非常自然。

传统循环 vs 基于 Range 的循环

#include <iostream>
#include <vector>

int main() {
    std::vector<int> v = {1, 2, 3, 4};

    // 旧式循环
    for (auto it = v.begin(); it != v.end(); ++it)
        std::cout << *it << ' ';

    // 基于范围的循环（C++11）
    for (auto x : v)
        std::cout << x << ' ';
}

Range Views（视图）

View 是惰性的、可组合的范围操作。除非需要，一般不会复制数据。

Filter 和 Transform 示例

#include <iostream>
#include <vector>
#include <ranges>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5, 6};

    auto even_doubled = v 
        | std::views::filter([](int n) { return n % 2 == 0; })
        | std::views::transform([](int n) { return n * 2; });

    for (int n : even_doubled)
        std::cout << n << ' ';  // 输出：4 8 12
}

常见的 Views

View	描述
std::views::filter	保留符合条件的元素
std::views::transform	对每个元素应用函数
std::views::take(n)	获取前 n 个元素
std::views::drop(n)	跳过前 n 个元素
std::views::reverse	反转范围
std::views::iota(a, b)	生成从 a 到 b-1 的范围

使用 iota 和 reverse

#include <ranges>
#include <iostream>

int main() {
    for (int i : std::views::iota(1, 6) | std::views::reverse)
        std::cout << i << ' '; // 输出：5 4 3 2 1
}

组合视图操作

你可以使用管道符 | 流式地组合多个视图操作。

#include <vector>
#include <ranges>
#include <iostream>

int main() {
    std::vector<int> v = {5, 10, 15, 20};

    auto result = v 
        | std::views::transform([](int x) { return x + 1; })
        | std::views::filter([](int x) { return x % 2 == 0; });

    for (int x : result)
        std::cout << x << ' '; // 输出：6 16
}

实用示例

1. 过滤偶数

#include <iostream>
#include <vector>
#include <ranges>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};

    auto evens = numbers 
        | std::views::filter([](int n) { return n % 2 == 0; });

    for (int n : evens)
        std::cout << n << ' ';  // 输出：2 4 6
}

2. 将奇数翻倍

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    auto doubled_odds = numbers
        | std::views::filter([](int n) { return n % 2 != 0; })
        | std::views::transform([](int n) { return n * 2; });

    for (int n : doubled_odds)
        std::cout << n << ' ';  // 输出：2 6 10
}

3. 反转序列

int main() {
    std::vector<int> nums = {10, 20, 30};

    auto reversed = nums | std::views::reverse;

    for (int n : reversed)
        std::cout << n << ' ';  // 输出：30 20 10
}

4. 生成数值序列

#include <ranges>

int main() {
    for (int i : std::views::iota(1, 6))
        std::cout << i << ' ';  // 输出：1 2 3 4 5
}

5. 获取前 N 个元素

int main() {
    auto infinite = std::views::iota(1); // 无限序列
    auto first5 = infinite | std::views::take(5);

    for (int i : first5)
        std::cout << i << ' ';  // 输出：1 2 3 4 5
}

6. 计算前 5 个奇数的平方和

#include <numeric>

int main() {
    auto odd_squares = std::views::iota(1)
        | std::views::filter([](int x) { return x % 2 == 1; })
        | std::views::transform([](int x) { return x * x; })
        | std::views::take(5);

    int sum = std::accumulate(odd_squares.begin(), odd_squares.end(), 0);
    std::cout << "和 = " << sum << '\n'; // 输出：和 = 165
}

7. 判断是否所有元素都为正数

#include <ranges>
#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> nums = {1, 2, 3};

    bool all_positive = std::ranges::all_of(nums, [](int n) { return n > 0; });

    std::cout << std::boolalpha << all_positive << '\n'; // 输出：true
}

8. 自定义管道函数

auto pipeline = [](const std::vector<int>& v) {
    return v 
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::views::transform([](int x) { return x * 10; });
};

int main() {
    std::vector<int> nums = {1, 2, 3, 4};

    for (int x : pipeline(nums))
        std::cout << x << ' '; // 输出：20 40
}

性能提示

Ranges 是惰性的：仅在需要时才处理元素。
避免不必要的分配与复制。
适合处理大型数据或函数管道。

何时不适合使用 Ranges

在对性能极度敏感的内循环中，STL 抽象可能较慢。
当项目尚未迁移到 C++20。

参考资料

英文：Tutorial on C++ Ranges

本文一共 415 个汉字, 你数一下对不对.

C++ Ranges 教程. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c C++ Ranges 教程 C++ C++ 学习笔记程序设计编程计算机

The post C++ Ranges 教程 first appeared on 小赖子的英国生活和资讯.

简易教程: C++的智能指针

小赖子

2025年5月16日 05:52

C++ 智能指针教程

C++ 中的智能指针提供了自动且安全的内存管理。它们通过 RAII（资源获取即初始化）机制，帮助开发者避免内存泄漏和悬空指针的问题，确保对象在生命周期结束时被正确释放。

本教程将介绍 C++ 中三种主要的智能指针：

std::unique_ptr：独占式所有权
std::shared_ptr：共享式所有权
std::weak_ptr：非拥有式弱引用

1. std::unique_ptr

unique_ptr 拥有独占所有权。一个资源只能被一个 unique_ptr 拥有。

示例：管理简单对象

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> p = std::make_unique<int>(42);
    std::cout << "值: " << *p << "\n";

    // 转移所有权
    std::unique_ptr<int> q = std::move(p);
    if (!p) std::cout << "p 现在是空指针\n";
    std::cout << "q 指向: " << *q << "\n";
}

示例：构建链表

struct Node {
    int val;
    std::unique_ptr<Node> next;
    Node(int v) : val(v), next(nullptr) {}
};

void printList(const std::unique_ptr<Node>& head) {
    const Node* curr = head.get();
    while (curr) {
        std::cout << curr->val << " ";
        curr = curr->next.get();
    }
    std::cout << "\n";
}

int main() {
    auto head = std::make_unique<Node>(1);
    head->next = std::make_unique<Node>(2);
    head->next->next = std::make_unique<Node>(3);

    printList(head);
}

2. std::shared_ptr

shared_ptr 允许多个指针共享同一个资源的所有权。它通过引用计数管理资源，当引用数为零时自动释放内存。

示例：共享资源

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> a = std::make_shared<int>(100);
    std::shared_ptr<int> b = a;

    std::cout << "a 的引用计数: " << a.use_count() << "\n";
    std::cout << "b 的引用计数: " << b.use_count() << "\n";
    std::cout << "*b = " << *b << "\n";
}

示例：共享链表节点

struct Node {
    int val;
    std::shared_ptr<Node> next;
    Node(int v) : val(v), next(nullptr) {}
};

3. std::weak_ptr

weak_ptr 是一种弱引用，不拥有资源，仅用于观察 shared_ptr 所管理的对象。它常用于打破循环引用，防止内存泄漏。

示例：打破循环引用

#include <iostream>
#include <memory>

struct B;

struct A {
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A 被销毁\n"; }
};

struct B {
    std::weak_ptr<A> a_ptr;
    ~B() { std::cout << "B 被销毁\n"; }
};

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->b_ptr = b;
    b->a_ptr = a;
}

是否存在 make_weak？

不存在 std::make_weak，因为 weak_ptr 不拥有资源，它必须引用一个已存在的 shared_ptr。

如何创建 weak_ptr

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> sp = std::make_shared<int>(42);
    std::weak_ptr<int> wp = sp;

    if (auto locked = wp.lock()) {
        std::cout << "值: " << *locked << "\n";
    } else {
        std::cout << "对象已被释放\n";
    }
}

总结

智能指针	所有权	线程安全的引用计数	典型用途
`unique_ptr`	独占	N/A	高效、安全的单一所有权
`shared_ptr`	共享	是	多个所有者共享资源
`weak_ptr`	无	N/A	打破 shared_ptr 的循环引用

C/C++编程

英文：Tutorial on C++ Smart Pointers

本文一共 375 个汉字, 你数一下对不对.

简易教程: C++的智能指针. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c 简易教程: C++的智能指针 C++ C++ 学习笔记程序设计编程计算机

The post 简易教程: C++的智能指针 first appeared on 小赖子的英国生活和资讯.

借助AI快速开源了三个小工具: 写代码越来越像做产品了, AI 真把我宠坏了(Vibe Coding)

小赖子

2025年5月16日 00:08

程序员的未来？Vibe Coding + AI 一起上！

借助 AI 快速开源了三个小工具

最近，我利用 ChatGPT-4o 和 o4-mini 快速开发并开源了三个小工具。起因其实很简单——每次想转换 YAML/JSON 或进行 Base64 编码时，我总是得去 Google 搜索在线工具。时间一久，我不禁开始思考：既然每次都要用，为什么不自己动手实现一个呢？正好我也在学习 React，把这个过程当作练习岂不是一举两得？

于是我开始“扮演”产品经理，向 ChatGPT 提出需求，它很快就为我搭建好了基础框架。包括项目结构、CI 工具（单元测试、ESLint——后来我换成了 Prettier）、README 文档，甚至是 GitHub Actions 上的自动化测试和部署流程，全部一气呵成。

这几个工具都部署在 GitHub Pages 上，开源、带测试、写了文档，虽然小巧，但功能完整，不需要自建服务器就能稳定运行，部署成本几乎为零。

YAML/JSON 转换工具

用于在 YAML 和 JSON 格式之间进行双向转换，支持美化和压缩，简单直观。

yaml-json-converter 借助AI快速开源了三个小工具: 写代码越来越像做产品了, AI 真把我宠坏了(Vibe Coding) ChatGPT (OpenAI) 人工智能 (AI) 小技巧程序员程序设计编程资讯软件工程

Yaml/Json数据格式转换React小程序

Base64 编码/解码工具

支持文字和文件的编码解码操作，可以将文件内容直接转换为 Base64 字符串，或者反向解析恢复文件。

base64-converter 借助AI快速开源了三个小工具: 写代码越来越像做产品了, AI 真把我宠坏了(Vibe Coding) ChatGPT (OpenAI) 人工智能 (AI) 小技巧程序员程序设计编程资讯软件工程

Base64编码解码React小工具

ROT47 混淆工具

这是一个轻量级的字符串混淆工具。ROT47 的特点是“加密两次即为原文”，类似于异或操作，适用于简单场景下的信息模糊处理。

rot47-converter 借助AI快速开源了三个小工具: 写代码越来越像做产品了, AI 真把我宠坏了(Vibe Coding) ChatGPT (OpenAI) 人工智能 (AI) 小技巧程序员程序设计编程资讯软件工程

ROT47 Cipher文本混淆React小工具

Markdown HTML转换

我又弄了一个，这个是把Markdown格式转换成HTML的，转换解释Markdown是基于 marked 库，所以并没有再造轮子。由于HTML转Markdown会比较复杂，这一版本就没有支持。

主要的活都让AI做了（编码/写测试/调CSS），我做的工作就是指导（Prompt Engineering）并把各个零件粘在一起。

markdown-html-converter 借助AI快速开源了三个小工具: 写代码越来越像做产品了, AI 真把我宠坏了(Vibe Coding) ChatGPT (OpenAI) 人工智能 (AI) 小技巧程序员程序设计编程资讯软件工程

Markdown/HTML转换工具/React Js WebApp

借助AI快速开源了三个小工具: 写代码越来越像做产品了, AI 真把我宠坏了(Vibe Coding). (AMP 移动加速版本)

程序员的门槛正在降低

AI 的发展速度太快了，现在生成代码的质量不仅更高，出错率也更低。即便出错，只需将报错信息交还给 AI，它就能分析并修正。程序员的角色正在转变：与其说是手工写代码，不如说是理解需求、与 AI 高效沟通，并拼装整合它给出的解决方案。

对我来说，项目最初的搭建一直是拖延的主要原因。ChatGPT 正好擅长这一环节——自动生成 boilerplate，让我几乎能“秒启动”一个新项目，显著提升了开发效率。

我已经养成每天使用 AI 的习惯，甚至已经很少再使用 Google 搜索。遇到问题，第一反应是直接问 ChatGPT，不仅快，还能一步到位解决问题。

Vibe Coding：AI 驱动的编程方式

Vibe Coding 这个概念今年特别火，核心思想是“用氛围编码”。也就是说，程序员不再执着于每一行代码的细节，而是通过自然语言描述需求，让 AI 来实现代码的生成、重构与调试。

Andrej Karpathy (2025)

TLDR；Vibe 编码是一种新兴的软件构建实践，它用简单的语言描述你想要的内容 – 然后让 AI 处理代码和测试。
TLDR; Vibe coding is the emerging practice of building software by describing what you want in plain language – and letting AI handle the code and test.

我发现自己越来越倾向于这种方式。遇到 bug，第一时间就将错误日志扔给 ChatGPT 处理。虽然效率很高，但也让我逐渐失去了深入思考和调试的乐趣。

现在还有很多支持 Vibe Coding 的工具，比如 Cursor，或者在 VSCode 中配置 AI Agent。你只需告诉它“我要实现什么”，它就能完成代码编写、框架搭建，甚至进行模块拆解和逻辑优化。而你要做的，仅仅是审查和接受它的建议——这不就是产品经理的工作吗？

初级程序员的挑战与机会

AI 工具的普及正在重塑编程的边界，传统“照着教程敲代码”的模式已经远远落后。未来，初级程序员面临的挑战不再是“学不会写代码”，而是“不会用 AI”。

想要不被淘汰，最重要的是掌握如何高效地与 AI 协作，提升自己的系统思考与设计能力。AI 是强大的助手，但人类的洞察、判断和创造，依然无可替代。

未来属于那些善于利用工具、不断精进自己思考能力的人。也许“写代码”的定义正在改变，但“解决问题”的本质永远不会变。

AI大大提高了生产力，执行力和创造力会更加重要。软件工程师需要懂得怎么用AI来干活拧螺丝（开发/调试/解决问题）。感觉程序员的门槛瞬间变得好低，只要懂得看懂AI生成的代码，懂得基本的软件工程就可以了。

ChatGPT 可以拿来做什么？

ChatGPT 通用人工智能

Grok 3

AI爆改吉卜力风格照片? ChatGPT-4o要收费, 但这里有免费方法!

字节/豆包/AI

字节豆包AI还是比较懂男性: 可能和抖音数据有关?

英文：From Idea to GitHub Pages: Building Tools with AI and Vibe Coding

本文一共 1373 个汉字, 你数一下对不对.

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c 借助AI快速开源了三个小工具: 写代码越来越像做产品了, AI 真把我宠坏了(Vibe Coding) ChatGPT (OpenAI) 人工智能 (AI) 小技巧程序员程序设计编程资讯软件工程

The post 借助AI快速开源了三个小工具: 写代码越来越像做产品了, AI 真把我宠坏了(Vibe Coding) first appeared on 小赖子的英国生活和资讯.

Ubuntu 系统无法通过 pip 命令安装 Python 库问题解决

杜老师说

作者Teacher Du

2025年5月12日 00:00

为了更好的执行 Python 脚本，杜老师习惯使用 Ubuntu 系统，不过在安装 Python 库时经常报错。收集了安装 Python 库的报错信息，并整理了解决办法，供需要的小伙伴们参考。

问题提示

这里以上一篇《使用 Python 脚本实现图片相似度匹配》文中代码为例，首次执行时的报错信息如下：

penn@penn-VMware-Virtual-Platform:~/图片$ python3 1.py
Traceback (most recent call last):
  File "/home/penn/图片/1.py", line 4, in <module>
    import imagehash
ModuleNotFoundError: No module named 'imagehash'

根据报错信息，提醒找不到 imagehash 模块，使用 pip3 命令安装需要的模块，结果又出现了错误信息。这个信息表明正在尝试在一个由操作系统管理的 Python 环境中直接安装 Python 相关的包，为了保证系统 Python 环境的稳定性和安全性而采取限制措施：

penn@penn-VMware-Virtual-Platform:~/图片$ pip3 install imagehash
error: externally-managed-environment

× This environment is externally managed
╰─> To install Python packages system-wide, try apt install
    python3-xyz, where xyz is the package you are trying to
    install.
    
    If you wish to install a non-Debian-packaged Python package,
    create a virtual environment using python3 -m venv path/to/venv.
    Then use path/to/venv/bin/python and path/to/venv/bin/pip. Make
    sure you have python3-full installed.
    
    If you wish to install a non-Debian packaged Python application,
    it may be easiest to use pipx install xyz, which will manage a
    virtual environment for you. Make sure you have pipx installed.
    
    See /usr/share/doc/python3.13/README.venv for more information.

note: If you believe this is a mistake, please contact your Python installation or OS distribution provider. You can override this, at the risk of breaking your Python installation or OS, by passing --break-system-packages.
hint: See PEP 668 for the detailed specification.

解决方法

解决的方法有很多，这里推荐使用虚拟环境。因为使用虚拟环境可以避免直接修改系统的 Python 环境，同时方便管理依赖。按照提示创建一个虚拟环境，使用 python3 -m venv myenv 来创建虚拟环境，使用 source myenv/bin/activate 激活虚拟环境：

1 2	penn@penn-VMware-Virtual-Platform:~/图片$ python3 -m venv myenv penn@penn-VMware-Virtual-Platform:~/图片$ source myenv/bin/activate

在激活虚拟环境后，使用以下命令安装所需的包。安装完成后运行命令 deactivate，退出虚拟环境：

(myenv) penn@penn-VMware-Virtual-Platform:~/图片$ pip install imagehash
Collecting imagehash
  Downloading ImageHash-4.3.2-py2.py3-none-any.whl.metadata (8.4 kB)
Collecting PyWavelets (from imagehash)
  Downloading pywavelets-1.8.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (9.0 kB)
Collecting numpy (from imagehash)
  Downloading numpy-2.2.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (62 kB)
Collecting pillow (from imagehash)
  Downloading pillow-11.2.1-cp313-cp313-manylinux_2_28_x86_64.whl.metadata (8.9 kB)
Collecting scipy (from imagehash)
  Downloading scipy-1.15.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (61 kB)
Downloading ImageHash-4.3.2-py2.py3-none-any.whl (296 kB)
Downloading numpy-2.2.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (16.1 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 16.1/16.1 MB 21.3 MB/s eta 0:00:00
Downloading pillow-11.2.1-cp313-cp313-manylinux_2_28_x86_64.whl (4.6 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.6/4.6 MB 38.6 MB/s eta 0:00:00
Downloading pywavelets-1.8.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (4.5 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.5/4.5 MB 38.6 MB/s eta 0:00:00
Downloading scipy-1.15.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (37.3 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 37.3/37.3 MB 41.4 MB/s eta 0:00:00
Installing collected packages: pillow, numpy, scipy, PyWavelets, imagehash
Successfully installed PyWavelets-1.8.0 imagehash-4.3.2 numpy-2.2.5 pillow-11.2.1 scipy-1.15.2

使用 Python 脚本实现图片相似度匹配

杜老师说

作者Teacher Du

2025年5月9日 00:00

随着相机像素越来越大，图片体积也变大了。在图片处理中，较大的文件体积会影响性能，因此杜老师会先生成缩略图，筛选完成后再通过 Python 脚本实现图片相似度匹配。这里是一个简单的示例，供需要的小伙伴们参考。

脚本说明

以下是个基于 Python 的脚本，使用 PIL 以及 imagehash 库来实现。

遍历目录 A 中所有图片。

在目录 B 中查找相似的图片「通过感知哈希算法判断」

如找到匹配项，则将图片复制到目录 C，并以目录 A 图片的名字命名。

安装依赖

1	pip install pillow imagehash

注意：在运行脚本前，需安装所需的 Python 库。

脚本示例

import os
import shutil
from PIL import Image
import imagehash

# 定义目录路径
dir_a = 'path/to/dirA'
dir_b = 'path/to/dirB'
dir_c = 'path/to/dirC'

# 设置相似度阈值（越小越严格）
threshold = 5

# 获取图片的感知哈希值
def get_image_hash(filepath):
    try:
        return imagehash.phash(Image.open(filepath))
    except Exception as e:
        print(f"无法处理文件 {filepath}: {e}")
        return None

# 判断两个哈希值是否相似
def is_similar(hash1, hash2):
    return hash1 - hash2 <= threshold

# 确保目标目录存在
os.makedirs(dir_c, exist_ok=True)

# 遍历目录 A
for filename in os.listdir(dir_a):
    file_a_path = os.path.join(dir_a, filename)
    
    # 检查是否为图片
    if not filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp')):
        continue
    
    hash_a = get_image_hash(file_a_path)
    if hash_a is None:
        continue

    # 遍历目录 B 寻找相似图片
    for b_filename in os.listdir(dir_b):
        file_b_path = os.path.join(dir_b, b_filename)
        
        # 检查是否为图片
        if not b_filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp')):
            continue
        
        hash_b = get_image_hash(file_b_path)
        if hash_b is None:
            continue

        if is_similar(hash_a, hash_b):
            # 构建目标路径
            file_c_path = os.path.join(dir_c, filename)
            # 复制并重命名文件
            shutil.copy(file_b_path, file_c_path)
            print(f"已找到匹配: {filename} -> {b_filename}, 已复制到 {file_c_path}")

注意：将 dir_a, dir_b 和 dir_c 替换为实际路径；threshold 控制图像相似度阈值，可以根据需要调整；支持多种常见格式图片文件；使用 imagehash.phash 进行感知哈希的比较，适合用于识别视觉上接近的图片。

运行效果

(myenv) penn@penn-VMware-Virtual-Platform:~/图片$ python3 1.py
已找到匹配: image105.jpg -> 1745928332994.jpg, 已复制到 c/image105.jpg
已找到匹配: image001.jpg -> 1745736425856.jpg, 已复制到 c/image001.jpg
已找到匹配: image017.jpg -> 1745736425221.jpg, 已复制到 c/image017.jpg
已找到匹配: image085.jpg -> 1745928334851.jpg, 已复制到 c/image085.jpg

注意：脚本运行过程可能会有错误提示，需要根据提示进行修复。

Alan Becker 的动画教学视频是非常好的启蒙材料

小赖子

2025年5月6日 01:34

$alan-becker-animation-vs-math-e-to-i-pi-2025-03-11-12.55.20-scaled Alan Becker 的动画教学视频是非常好的启蒙材料学习笔记教育数学物理编程视频计算机资讯$

虚数i*i*i=-i 也就是i*e^(ipi)

自从去年家里装修完之后，我们在厨房装了一台电视，平时吃饭时会随便看看一些视频。大约两个月前的一天中午，我从学校接弟弟回家吃饭，无意间发现了一个叫 Alan Becker 的动画视频系列——“Animation vs.”，是 YouTube 上的一个非常有创意的系列。他最出名的作品之一就是《Animation vs Math》。

Alan Becker 的这些视频通常用一群小人（也有人叫他们“小黄人”、小橙色、火柴人）在电脑屏幕上互动的方式，讲述一个个富有创意、又带有教育意义的故事。虽然整个系列几乎没有一句对白，但却通过画面和动作把复杂的知识点讲得既直观又有趣。

我最喜欢的四个视频是《Animation vs Math》、《Animation vs Coding》、《Animation vs Physics》和《Animation vs Geometry》。每一集不仅让人捧腹大笑，还让人对背后的知识产生兴趣。比如在《Animation vs Math》中，小人们在坐标系、函数图像之间跳跃和作战，看得人不知不觉就理解了各种数学概念。而《Animation vs Coding》则展示了编程的魔法，小人甚至“黑进”了主人的电脑，自己写代码！《Animation vs Physics》里，小人们挑战了牛顿定律、重力和能量守恒，用夸张但合理的方式演绎了物理知识。

《Animation vs Geometry》则是另一个令人惊喜的作品。视频里，小人们与各种几何图形互动，有时被三角形包围，有时从正多边形中逃脱，有时又在空间几何中穿梭。通过他们的“冒险”，我对角度、面积、对称和旋转等概念有了更加立体的理解。这些原本在课堂上觉得枯燥的几何知识，突然变得生动起来。

现在每次吃饭的时候，我和弟弟都会打开一集，一边看一边讨论背后的知识点。他有时候还会模仿小人画画、写代码，看得津津有味。比起传统的教学方式，这种寓教于乐的视频真的非常适合启发孩子的兴趣，也让我重新发现了学习的乐趣。

Alan Becker 的动画视频在 YouTube 上非常火，常常能获得数百万甚至上亿的浏览量。很多 UP 主还会专门制作 Reaction（观看反应）视频，一边观看一边讲解其中的知识点，让观众能更深入地理解动画背后的内容。

我真心希望 Alan Becker 能继续制作这个系列的视频。他的作品不仅有趣，还兼具知识性和创意性，每一集都能带来惊喜。我还特地去看了一下他的 YouTube 主页，发现他有自己的网站和线上小店，里面出售一些周边商品和纪念品，比如角色贴纸、T 恤、鼠标垫等等。通过这些方式，粉丝们也能支持他继续创作。

如果我在初高中时就能看到这样的动画视频，可能我的学习态度和兴趣都会大不一样，说不定我也不会变成所谓的“学渣”。Alan Becker 的这些作品用轻松有趣的方式，把复杂的知识讲得通俗易懂、引人入胜。我相信，这样的内容一定能激励无数学生，让他们重新发现学习的乐趣，也让知识变得真正“活”起来。

这些视频的背景BGM音乐也非常出色，节奏紧凑、氛围感强，不仅很好地配合了剧情发展，还增强了观众的代入感。每当剧情进入高潮或角色展开大战时，音乐的节奏也随之加快，让人不自觉屏住呼吸、全神贯注。可以说，音乐和动画配合得天衣无缝，是整个系列成功的重要一环。

Alan Becker 的 Animation 系列动画教学视频

Alan Becker 在油管的频道有3000万+粉丝。

Animation vs Math 数学

这是我最喜欢的视频之一。它是在一年前上传的，如今已经有超过 8000 万的播放量。视频的开头从数学中最基础的常量“1”出发，接着逐步引入加减乘除等基本运算，再到实数与虚数，最后主角“-1”展开了一场围绕著名公式 $tex_39ab8c54661fe3603377d1d4de5601e0 Alan Becker 的动画教学视频是非常好的启蒙材料学习笔记教育数学物理编程视频计算机资讯$ 的激烈格斗故事。

整个视频既紧凑又富有张力，把一个高度抽象的数学公式，用动画的方式生动演绎出来。观众不需要具备高深的数学背景，也能感受到其中的逻辑美和力量感。尤其是当角色“i”（虚数单位）和“π”共同施展出终极公式的那一刻，既震撼又令人忍俊不禁。

这也是 Alan Becker 的动画魅力所在：用可视化的手法，把严肃甚至有些晦涩的知识，变成一个个有趣的、像电子游戏一样的冒险故事。对我来说，看完这部视频后，对欧拉公式产生了浓厚的兴趣，后来还专门去查资料，才知道这个等式被称为“数学中的诗”。

哥哥弟弟也很喜欢这一集，他虽然年纪还小，看不懂太多公式，但他能理解角色之间的战斗与变化，这就足够吸引他了。我们甚至还尝试用积木和纸画重现其中的几幕场景，边玩边学，乐在其中。

哥哥也很喜欢数学，平时在学校数学成绩是班上最好的，希望这个视频能启蒙到他。

我最喜欢的一幕就是当 $tex_96cad1e5ef25c476c3be4eb8d105669c Alan Becker 的动画教学视频是非常好的启蒙材料学习笔记教育数学物理编程视频计算机资讯$ 化身为 Transformer 形态，用手上的 “limit” 装置接住了小黄人化身的 $tex_02d375c3338b3ac7e6c3b81fb6e031b5 Alan Becker 的动画教学视频是非常好的启蒙材料学习笔记教育数学物理编程视频计算机资讯$ 这一幕不仅视觉上震撼，也充满了数学梗的巧思。将抽象的公式和极限概念具象化成角色之间的对抗和救援，真的是把“知识即力量”演绎到了极致。

很享受这种知识划过脑却不留痕迹的感觉。

数学知识
0:07 最简单的入门方式——1 是第一个自然数，这是公理化的（尽管在一些数学分析教材中，他们首先指出 0 是自然数）。
0:13 等式——数学课上学习的两个对象之间的第一个关系。
0:19 加法——四种基本算术运算中的第一个。
0:27 重复 1 的加法，这是我们在集合论中定义其余自然数的方式；也是乘法的铺垫。
0:49 与 1 以外的数字进行加法，这可以用我们已知的 1 加法来定义。（省略证明）
1:23 减法——四种基本算术运算中的第二个。
1:34 我们的第一个负数！它也可以表示为 $tex_8c4d4d144d960c160796f47c59507535 Alan Becker 的动画教学视频是非常好的启蒙材料学习笔记教育数学物理编程视频计算机资讯$ ，这是将 $tex_0e4258221bdbc1e8dd20cfdd36fa4447 Alan Becker 的动画教学视频是非常好的启蒙材料学习笔记教育数学物理编程视频计算机资讯$ 的泰勒级数的定义域扩展到复数的结果。
1:49 $tex_8c4d4d144d960c160796f47c59507535 Alan Becker 的动画教学视频是非常好的启蒙材料学习笔记教育数学物理编程视频计算机资讯$ 乘以 i，这打开了一扇通往……虚数世界的大门？这也暗示了小黄人实际上存在于实数世界。TSC 现在如何再次得出这个量？

2:12 重复减 1，类似于对自然数的操作。
2:16 负数乘以负数得正数。
2:24 乘法，以及通过重复加法或任何运算对其进行的解释。
2:27 乘法的交换律，以及 12 的因数。
2:35 除法，最后的算术运算；也很好地展示了 – 和 / 之间的关系，就像 + 和 x 之间的关系一样！
2:37 除法就是计算重复减法的次数，直到零。
2:49 除以零，以及为什么它没有意义。令人惊讶的是，TSC 没有用这个来制造一个黑洞。

3:04 指数运算是重复的乘法。
3:15 高阶指数如何对应几何维度。
3:29 任何非零的零次方都是1。
3:31 负指数！以及它与分数和除法的关系。
3:37 分数指数和平方根！我们越来越接近了……
3:43 无理数（例如 sqrt(2)）的小数展开是不规则的。（我避免使用“无穷大”这个词，因为从技术上讲，每个实数的小数展开都是无穷大的……）
3:49 sqrt(-1) 给出虚数 i，它首先由性质 i^2 = -1 定义。
3:57 复数的加法和乘法是根据我们已知的原理进行的。
4:00 i^3 等于 -i，这当然会得到 i*e^(i*pi)！

4:14 参考 3:49
4:16 欧拉公式 x = pi！这个公式可以通过重新排列 e^x 的泰勒级数来表示。
4:20 小细节：被负号击中会改变 TSC 的方向，这又一次暗示了复平面！
4:22 e^(i*pi) 到 e^0 对应于复平面上沿单位圆的运动。
4:44 +1/-1 的“剑”相互碰撞，发出“0”个火花。
4:49 -4 的剑击中 +1 的剑，变为 -3，等等。
4:53 2+2 的弩射出 4 支箭。
4:55 4 支箭击中除号，与 pi 对齐，得到 e^(i*pi/4)，使其沿单位圆旋转 pi/4 弧度。
5:06 TSC 通过乘以 i 来推动自己，围绕单位圆旋转 π 弧度。

5:18 TSC 终于发现了复平面！5:21 虚轴；5:28 实轴。
5:33 最简单的单位圆。
5:38 圆中的 2*π 弧度。
5:46 弧度的定义——单位圆中跨越长度为 1 的弧度的夹角。
5:58 r*theta——半径为 r 的圆中，夹角为 theta 的圆弧长度公式。
6:34 对于单位圆来说，theta / r 就是角度。
6:38 圆周的一半正好是 π 弧度。
6:49 正弦函数和余弦函数如何与绕单位圆逆时针旋转相关——sin(x) 等于 y 坐标，cos(x) 等于 x 坐标。
7:09 旋转 sin(x) 可以直观地看到 sin(x) 和 cos(x) 之间的位移。
7:18 参考 4:16

7:28 将指数改变为 π 的倍数，使其向各个方向移动。
7:34 一个新形式！？e^x 的泰勒级数，其中 x=i*π。现在它有无限的弹药了！？同样，弹药将每个项的十进制展开式作为其弹道标记。
7:49 面积为 pi r^2，高为 8 的圆柱体的体积。
7:53 给读者的练习（哈哈）
8:03 参考 4:20
8:25 关于 e^(ix) 的 cos(x) 和 sin(x)
8:33 很遗憾，这部分我看不懂……TSC 创建了一个“函数”枪 f(x) = 9tan(pi*x)，这样朝 e^(i*pi) 射击会得到 f(e^(i*pi))= f(-1) = 0。
9:03 参考 5:06
9:38 “函数”枪现在在无穷远处“求值”，通过每次增加一个维度来扩展实空间（它是一个向量空间），即实空间的跨度扩展为 R^2、R^3 等。
9:48 log((1-i)/(1+i)) = -i*pi/2，乘以 2i^2 = -2 再次得到 i*pi。
9:58 通过缩短间隔并取极限来阻挡“无穷大”光束，这并非黎曼积分的精确定义，但足够接近了。

油管视频：Animation vs Math

Animation vs Coding 编程

编程这一集我看得最懂了，也很有意思，特别是当中那个原子弹的Python程序，就是无限递归/Recursion内存爆炸。

def nuke(n):
    a = []
    for i in range(10):
        if n > 1:
            a.append(nuke(n - 1))
        else:
            a.append(i)
    return a

print(nuke(10))

还有就是Python里调用Turtle包进行海龟作图（这可是我学编程的第一个编程语言）也相当有创意。

0:18 未定义 – 计算机不知道这是什么，就是这样
0:34 print() 将内容打印到终端
0:42 重新运行代码
0:52 变量
1:00 运算（* 表示乘法，/ 表示除法）
1:05 向下取整除法（删除小数）
1:10 字符串本质上就是可以使用的文本
1:23 不能将数字和字符串一起使用
1:27 让你专注于一个特定的字符串/变量/数字
1:32 对象中的项目数（在本例中为 7，因为 string7 有 7 个字符）
1:38 代码语法错误
1:45 b 本质上是 a 中的字符（所以 a[5] 应该是 g，而不是 n，因为它从 0 开始）
1:48 重复代码数字/字符串长度
2:00 基本上会一直运行，因为它基本上告诉计算机“当 true 为真时”
2:02 大写显然
2:09 如果你在执行 while、if 或 for 之类的循环，需要将循环内部运行的代码推送进去，这样计算机才能知道你想要循环的代码。
2:16 循环内部的代码不是在 a 可打印的情况下运行，因为 a 可打印，所以它不能运行。
2:23 循环内部的代码在 if 不可打印的情况下运行。
2:32 字符串列表，本例中的 * 表示将所有字符串都考虑在内。
2:40 海龟本质上就是一支铅笔，我们在这里定义了海龟（所以我们可以直接写 t），然后 import 函数会从库中导入内容（库中有内置库）。
2:41 400 表示它在方向上移动的增量。
2:52 改变海龟移动的速度。
2:55 左右移动使海龟转向。
3:03 循环海龟的移动。
3:17 pensize 表示线条的面积。
3:32 这实际上是停止海龟的方法。哈哈
3:44 matplotlib 是一个绘图库（它显然可以让你访问图表和图形），numpy 允许你使用三维数组
3:44 插入绘图然后使其显示
3:58 获取一个随机的三维整数
4:20 绘图标题，太棒了
4:29 函数，让你在运行函数名称时运行这组代码
4:41 pygame 是一个令人惊讶的库，可以让你制作游戏！while true 循环用于检查用户是否关闭了窗口/选项卡
4:44 窗口的基本 pygame 代码
4:57 允许你通过按下某些键来移动对象
5:21 圆圈朝黄色的位置移动，向前移动时加速，向后移动时减速（谢谢 xTI0）
6:22 不要这样做。核函数中的数字表示列表嵌套的次数，所以 10 基本上就是递归地嵌套 10 次，非常卡顿
6:35 # 让你直接输入文本，非常适合解释你的代码是如何工作的
7:36 他真的在写一个 AI 代码
7:50 神经网络正在接受训练

快速提示：还记得最后提到这是 Python 吗？还有其他编程语言用于不同的目的，我想这很明显，但为了以防万一，一些流行的编程语言是 C、HTML、JavaScript 等等！

油管视频：Animation vs Coding

Animation vs Physics 物理

《Animation vs Physics》这一集的后半段内容变得相当深奥，涉及到了相对论、黑洞等高阶物理概念。我目前的理解还停留在初高中学过的一些基础知识，比如牛顿的第二定律 $tex_9daa187e47eb4fb749102377832e3148 Alan Becker 的动画教学视频是非常好的启蒙材料学习笔记教育数学物理编程视频计算机资讯$ 、动能定理、还有爱因斯坦著名的能量公式 $tex_76dbfb9a84d34d7f746b1f4cbbb81919 Alan Becker 的动画教学视频是非常好的启蒙材料学习笔记教育数学物理编程视频计算机资讯$ 。

虽然看不太懂后面的部分，但前半段关于力、加速度、重力等基础物理的呈现还是非常有趣的。角色们像在玩一场“现实模拟游戏”，各种物理定律在他们的世界里都有了视觉化的呈现，哪怕是没怎么学过物理的人也能看得津津有味。

0:19 加速度和速度
1:18 质量
3:07 势能
4:17 重力
4:38 米/秒
5:55 以更高的速度围绕行星运行
6:00 以米/秒为单位的速率增加
6:12 围绕其他行星的速度将随机倍增
基于其大小
6:40 围绕恒星的速度将根据其大小而倍增
7:05 是β的1%
7:21 磁场和引力
7:40 磁场环
7:48 制作磁场火箭
8:18 火箭速度因磁场火箭而加快
8:33 观察星系、星系系统和其他
9:14 黑洞
9:30 关于黑洞的事实
10:03 黑洞内部

油管视频：Animation vs Physics

Animation vs Physics 几何

说到几何，它是数学的另一个重要分支，其中最著名的“主角”之一就是黄金分割。黄金分割不仅在几何中占有一席之地，还常被视为“数学之美”的代表。比如大家熟悉的斐波那契数列，就和黄金分割密切相关——随着数列不断增长，相邻两项的比例会越来越接近黄金比例。

黄金分割的魅力不仅仅体现在数学里，在自然界、艺术、建筑甚至音乐中都有它的身影。像贝壳的螺旋、向日葵的花盘、古希腊神庙的比例，甚至名画《蒙娜丽莎》的构图，都被认为与黄金分割有关。

Alan Becker 在《Animation vs Geometry》中也通过角色与几何图形的互动，让我们直观地看到了这些数学背后的和谐与美感。通过一场看似搞笑却充满巧思的冒险，观众不仅被娱乐到了，也潜移默化地接触到了黄金分割等几何概念。

油管视频：Animation vs Geometry

油管视频 / Youtube Video

英文：Animation Youtube Videos from Alan Becker

本文一共 3926 个汉字, 你数一下对不对.

Alan Becker 的动画教学视频是非常好的启蒙材料. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c Alan Becker 的动画教学视频是非常好的启蒙材料学习笔记教育数学物理编程视频计算机资讯

The post Alan Becker 的动画教学视频是非常好的启蒙材料 first appeared on 小赖子的英国生活和资讯.

使用 Python 脚本下载指定网页的图片文件

杜老师说

作者Teacher Du

2025年3月31日 00:00

有小伙伴反馈说侧边栏随机图出现了重复，有些审美疲劳，要求杜老师再更新一些图片，正好聊天广场有小伙伴分享了一个美图的网址。本文分享如何使用 Python 脚本下载指定网页的图片文件，需要的小伙伴可以参考文中代码。

代码需求

使用 Python 的语言编写一个脚本，下载指定网址中包含的多种格式图片文件，如 JPG 和 PNG 格式图片。

将图片保存至指定的目录中，可以指定绝对路径，或者相对路径。

并用随机数重命名，防止同名图片触发覆盖事件。

尽可能使用 Python 的标准库，尽量避免使用第三方库。

变更解释

导入必要的库：包括 os/requests/re 以及 random；
定义函数：download_images 函数可用于下载图片；
获取图片链接：使用正则表达式从网页内容中提取图片 URL；
下载保存图片：使用 requests 库下载图片，并且使用 random 库生成随机数作为文件名；
指定目录：确保保存目录存在，如果不存在则创建；
获取内容：使用 requests 库获取网页内容。

功能代码

import os
import requests
import re
import random

def download_images(url, save_folder):
    # 确保保存目录存在
    if not os.path.exists(save_folder):
        os.makedirs(save_folder)

    # 发送HTTP请求获取网页内容
    response = requests.get(url)
    if response.status_code != 200:
        print(f"Failed to retrieve the webpage. Status code: {response.status_code}")
        return

    # 使用正则表达式查找所有的图片URL
    image_urls = re.findall(r'<img[^>]+src=["\'](.*?)["\']', response.text)

    for img_url in image_urls:
        # 处理相对路径的URL
        if not img_url.startswith(('http://', 'https://')):
            img_url = os.path.join(url, img_url)

        # 下载图片
        img_response = requests.get(img_url)
        if img_response.status_code == 200:
            # 生成随机文件名
            random_filename = f"{random.randint(10000, 99999)}.jpg"
            save_path = os.path.join(save_folder, random_filename)

            # 保存图片
            with open(save_path, 'wb') as f:
                f.write(img_response.content)
            print(f"Downloaded and saved {img_url} as {save_path}")
        else:
            print(f"Failed to download {img_url}. Status code: {img_response.status_code}")

# 读取网址列表文件
def read_urls_from_file(file_path):
    with open(file_path, 'r') as file:
        urls = file.readlines()
    return [url.strip() for url in urls]

# 示例调用
if __name__ == "__main__":
    urls_file = 'f:\\代码\\urls.txt'  # 包含网址的文件路径
    save_folder = 'f:\\代码\\images'  # 保存图片的目录路径

    urls = read_urls_from_file(urls_file)
    for url in urls:
        download_images(url, save_folder)

注意：本示例代码仅适用于 Python 3.x 版本，运行于 Windows 系统。如使用 Linux 系统，可能需要进行相应修改。

使用说明

将上述的代码保存为 download_images.py 文件。

在运行脚本时，传入目标网页的 URL 和保存图片的目录路径。

脚本会自动下载网页中所有图片，并且以随机数命名保存到指定目录中。

打开的网址保存在一个文件，每行一个网址。

如何构建一个具有重试机制的 Steem 区块链见证人投票检查器

小赖子

2025年4月7日 23:15

当使用像 Steem 这样的去中心化平台时，重要的是要预期偶尔的故障——网络问题、API 限制或暂时的停机。这就是为什么你构建的任何集成、机器人或工具都应该能够优雅地失败并智能地恢复。

在这篇文章中，我将带你了解一个简单而强大的 Steem 区块链见证人（也就是STEEM上的矿工）投票检查工具：

第一版：检查是否由某个见证人投票

这是一个实用的 Node.js 函数，用于检查一个 Steem 用户是否投票支持了某个特定的见证人——无论是直接投票还是通过代理。

function is_voted_by(witness, id) {
    return new Promise((resolve, reject) => {
        steem.api.getAccounts([id], function(err, response) {
            if (err) reject(err);
            if (typeof response == "undefined") reject("undefined");
            const data = response[0];
            resolve((data.proxy === witness) || data.witness_votes.includes(witness)); 
        });          
    });
}

它获取给定 id 的账户数据，然后检查该用户是否设置了匹配目标见证人的投票代理，或者该见证人是否在他们的直接投票列表中。

启用重试的 Steem 见证人投票检查器

这是更新版的函数，包含简单的重试机制（最多重试 3 次，每次重试间隔 1 秒）。以下的代码加入了重试功能：

function is_voted_by(witness, id, retries = 3) {
    return new Promise((resolve, reject) => {
        const attempt = (remaining) => {
            steem.api.getAccounts([id], function(err, response) {
                if (err || typeof response === "undefined") {
                    if (remaining > 0) {
                        setTimeout(() => attempt(remaining - 1), 1000); // 重试 1 秒后
                    } else {
                        reject(err || "undefined response");
                    }
                    return;
                }
                const data = response[0];
                resolve((data.proxy === witness) || data.witness_votes.includes(witness)); 
            });
        };
        attempt(retries);
    });
}

此版本在 Steem API 调用失败或返回 undefined 时最多进行 3 次重试，帮助处理不稳定的网络状况或临时的 API 问题。功能保持不变：检查直接的见证人投票或代理委托/Proxy。

重试的指数退避机制

使用指数退避机制/Exponential backoff来避免过度请求 API，并记录每次尝试以便于调试和更好的可视化。

module.exports.is_voted_by = function(witness, id, retries = 3, delay = 1000) {
    return new Promise((resolve, reject) => {
        const attempt = (remaining, currentDelay) => {
            console.log(`Checking vote for "${id}" against witness "${witness}"... (${retries - remaining + 1}/${retries})`);

            steem.api.getAccounts([id], function(err, response) {
                if (err || typeof response === "undefined") {
                    console.warn(`Attempt failed: ${err || 'undefined response'}`);
                    
                    if (remaining > 0) {
                        console.log(`Retrying in ${currentDelay}ms...`);
                        setTimeout(() => attempt(remaining - 1, currentDelay * 2), currentDelay); // 指数退避
                    } else {
                        reject(err || "undefined response after retries");
                    }
                    return;
                }

                const data = response[0];
                const voted = (data.proxy === witness) || data.witness_votes.includes(witness);
                console.log(`Vote check result: ${voted}`);
                resolve(voted);
            });
        };

        attempt(retries, delay);
    });
};

该函数：

调用 Steem API 获取给定 id 的账户信息。
检查用户是否投票支持某个特定的见证人，检查方式包括：直接投票（即 witness_votes 中包含该见证人），或通过代理投票（即 proxy === witness）。

如果 API 调用失败或返回 undefined，它将：

等待一段时间，
重试（最多重试 retries 次），
并且每次的等待时间按指数方式增加（1秒、2秒、4秒等）。

为什么要使用指数退避？

指数退避是网络编程中的经典策略——如果服务暂时不可用，快速连续请求只会让问题更加严重。通过在重试之间增加延迟，可以让系统有时间恢复，并且对 API 更加友好。

is_voted_by('witness-name', 'username')
    .then(voted => {
        if (voted) {
            console.log("User supports the witness!");
        } else {
            console.log("User has not voted for the witness.");
        }
    })
    .catch(err => {
        console.error("Error checking vote:", err);
    });

最后的思考

在构建与区块链交互的工具时，弹性至关重要。适当的重试逻辑能大大提高你的应用程序的稳定性和用户友好性——即使在底层基础设施出现问题时也能保持正常运行。

Steem/Steemit区块链

英文：

本文一共 672 个汉字, 你数一下对不对.

如何构建一个具有重试机制的 Steem 区块链见证人投票检查器. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c 如何构建一个具有重试机制的 Steem 区块链见证人投票检查器 Javascript STEEM 区块链区块链程序设计

The post 如何构建一个具有重试机制的 Steem 区块链见证人投票检查器 first appeared on 小赖子的英国生活和资讯.

力扣刷题打卡2209天竟然断了, 哎

小赖子

2025年3月21日 04:55

坚持6年的力扣刷题打卡作天断了。昨天开了一整天brainstorming 晚上陪媳妇过生日。然后就给忘了，还好的是力扣国服还没断。

2019年3月2日我在美国通用电气午休的时候太无聊拿起IPAD就刷了一题。

谁曾想：这一刷就是2209天。这六年时过境迁，很多事情物是人非。我也从美国通用电气GE（General Electric）到亚马逊 Amazon AWS 再到现在的微软剑桥研究院MSRC。

leetcode-2209-days-streak-ended 力扣刷题打卡2209天竟然断了, 哎程序员编程计算机计算机

力扣刷题打卡2209天始于2019年3月2日，终止于2025年3月19日，可惜了。

力扣每日一题打卡是可以补签的，只需要花70点积分就可以 Time Travel 回到本月补上一签。只不过那个墙是补不了的，没刷就是空的。

leetcode-from-2013-to-2024-scaled 力扣刷题打卡2209天竟然断了, 哎程序员编程计算机计算机

从2013年到2024的力扣刷题之路。

力扣美服是可以同步到国服的，但是目前是没有办法反过来把国服的刷题记录复制一份到美服的。可能，这就是注定的吧，肯定会有不完美的。还好我不是处女座，这么一点不完美不会逼疯我的，哈哈。我还是会继续刷题的。刷题努力提升自己，好处多多。

刷题：程序员的基本技能

本文一共 410 个汉字, 你数一下对不对.

力扣刷题打卡2209天竟然断了, 哎. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c 力扣刷题打卡2209天竟然断了, 哎程序员编程计算机计算机

The post 力扣刷题打卡2209天竟然断了, 哎 first appeared on 小赖子的英国生活和资讯.

如何使用 GDB 或 LLDB 调试器重复运行程序直到错误

小赖子

2025年3月21日 04:35

gdb-debugger 如何使用 GDB 或 LLDB 调试器重复运行程序直到错误 gdb / lldb 小技巧程序员编程计算机计算机调试

GDB Debugger 调试器

如何使用 GDB 或 LLDB 调试器重复运行程序直到发生错误

在调试程序时，有时候我们希望一直运行程序直到遇到错误。GDB（GNU 调试器）和 LLDB（LLVM 调试器）都提供了自动化此过程的方法。

这在调试一些不稳定的程序非常有用，例如有时候写的一些单元测试可能随机崩溃SegFault。最近我在调试一个测试每跑1000次就有一次崩溃的时候就发现gdb/lldb调试器非常有用。

简介：GDB vs LLDB

GDB（GNU 调试器）和 LLDB（LLVM 调试器）是用于低级别应用程序调试的强大工具。GDB 传统上用于由 GCC 编译的程序，而 LLDB 是 LLVM 项目的一部分，与 Clang 无缝配合。两者都提供强大的功能，但 GDB 在 Linux 环境中更常见，而 LLDB 在 macOS 上以及处理 Swift 时更受青睐。

自动化执行直到发生错误

调试重复性任务可能很乏味。通过自动化这些任务，直到发生错误，可以节省大量时间和精力。以下是如何在 GDB 和 LLDB 中设置重复执行直到遇到错误的步骤。

GDB 脚本

下面是一个 GDB 脚本，它会重复执行，直到发生错误：

repeat_until_error.gdb

while 1
  run
  if $_exitcode != 0
    echo "发生错误，退出码：$_exitcode\n"
    break
  end
end

要运行此脚本，将其保存为 repeat_until_error.gdb，然后使用以下命令执行 GDB：

gdb -q -x repeat_until_error.gdb ./your_program

或者，当你处于 gdb 提示符时，运行：

source repeat_until_error.gdb

“run” 命令用于启动程序，你可以为它添加参数，例如：

run param1 param2 ...

你也可以使用 “r” 作为 “run” 的简写。

LLDB 脚本

类似地，在 LLDB 中，你可以使用以下脚本实现相同的效果：

repeat_until_error.lldb

while (1)
  run
  process launch
  if (process status != 0)
    script print("发生错误，退出码：", lldb.process.GetExitStatus())
    break
  end
end

要运行此脚本，将其保存为 repeat_until_error.lldb，然后运行：

lldb --source repeat_until_error.lldb ./your_program

或者，在 lldb 提示符处运行：

source repeat_until_error.lldb

在 “run” 命令之后，你还可以通过附加参数来启动程序，例如：

run param1 param2

总结

GDB 和 LLDB 都提供了方便的方法来自动化调试任务，选择使用哪种工具通常取决于你所使用的平台和工具链。GDB 与 GCC 的集成使其成为 Linux 开发者的首选，而 LLDB 在与 Clang 和 macOS 的无缝配合方面同样强大。

自动化重复的调试命令可以为你节省大量时间和精力 —— 无论你使用 GDB 还是 LLDB，这些脚本都能帮助你简化工作流程。

gdb / lldb 调试

如何使用 GDB 或 LLDB 调试器重复运行程序直到错误

英文：How to Repeat Until Errors using GDB or LLDB Debugger?

本文一共 603 个汉字, 你数一下对不对.

如何使用 GDB 或 LLDB 调试器重复运行程序直到错误. (AMP 移动加速版本)

扫描二维码，分享本文到微信朋友圈

75a5a60b9cac61e5c8c71a96e17f2d9c 如何使用 GDB 或 LLDB 调试器重复运行程序直到错误 gdb / lldb 小技巧程序员编程计算机计算机调试

The post 如何使用 GDB 或 LLDB 调试器重复运行程序直到错误 first appeared on 小赖子的英国生活和资讯.

效率工具链构建与SSH防护实践

云心怀鹤

作者寻鹤

2025年3月6日 22:17

Typora使用很早就安装有这款应用，但没有重视，最近改主题每改一部分就需要复制备份出来，很不方便。找到了吃灰的typora工具，很方便，熟悉Markdown的很容易入手，##添加后，左侧点击标题就...

隐私保护：由于图片显示问题，部分内容已被隐藏，详细信息请通过原文链接查看。
版权声明：本文所有内容均采用 (CC BY-NC-ND 4.0)，转载需保留出处。
原文链接：效率工具链构建与SSH防护实践

娃开始每天都在刷力扣, 他长大以后想当软件工程师

小赖子

微博：我娃又在淘气了. 一身反骨: 我娃说他是想看看多添加几个if 会不会slow it down

2025年3月3日 03:33

弟弟说，他想像我一样长大后成为一名程序员。然而，随着人工智能/AI（比如ChatGPT）的飞速进化，未来或许程序员这个职业都会被取代。这一两年，互联网大厂的招聘也明显减少了。

不过，我依然认为学习编程是一件好事。写程序不一定是为了当码农，刷题可以锻炼思维。之前教了他 700 天编程，但从未让他真正写代码，大概已经忘得差不多了。现在每天带着他刷题，也算是一次复习与再学习的过程。

对我来说，每天陪着他一起刷题，其实也相当于我自己做了一题。大部分时间里，我不亲自敲代码，而是我讲解，孩子来动手，这样能让他更熟悉代码，学得更快。

merge-two-binary-trees-leetcode-by-ryan 娃开始每天都在刷力扣, 他长大以后想当软件工程师教娃教育程序员编程育儿

我娃又在淘气了. 一身反骨: 我娃说他是想看看多添加几个if 会不会slow it down

相比之下，哥哥对金融更感兴趣，未来想从事相关行业，所以我没有强求他一起刷题，但有时候他也会在一旁听着。

乔布斯曾说：“这个国家的每个人都应该学习编程，因为编程能教会你如何思考。”（It teaches people how to think.）

perse-school-cambridge-visit-steve-jobs-quote-2024-09-28-10.16.58-scaled 娃开始每天都在刷力扣, 他长大以后想当软件工程师教娃教育程序员编程育儿

乔布斯的名言：这个国家的每个人都应该学编程，它教会里如何思考。Every person in this country should learn how to program, as it teaches you how to think.

21 天可以养成习惯

我的儿子现在每天都在刷题，他说想成为一名软件工程师。但他还不知道，ChatGPT 正在统治世界，未来可能不再需要那么多程序员，尤其是初级工程师。

自己这辈子也就这样了，看不到希望，所以鸡个娃。每天带着娃刷力扣，等于自己也刷了一道。

ryan-leetcode-21-days-streak 娃开始每天都在刷力扣, 他长大以后想当软件工程师教娃教育程序员编程育儿

每天弟弟都在刷力扣希望他能坚持下来

Leetcode/力扣多人协作代码房间

娃经常会在Google Talk上给我发力扣房间链接，邀请我看他实时敲代码，这个功能挺好，多人协作编辑文档。N年前QQ聊天对话框也有一个这种即时模型，可以实时看到对方敲的文字。

leetcode-room-with-my-son 娃开始每天都在刷力扣, 他长大以后想当软件工程师教娃教育程序员编程育儿

力扣的这个房间功能挺好，娃开了房间，我就能同步看到他敲代码，也能同时指点帮助他进步！

教娃编程

刷题：程序员的基本技能

英文：My 10-yr old son starts to do leetcode every day
英文：Leetcode’s Coding Room – Real time Coding Collaboration (Coding Interview)
英文：My son wants to know if “too many if-s” would slow the code down

弟弟刷题 vlog – 刷题要从娃娃卷起

2025-04-07：Ryan 每天都在练 LeetCode。他正在厨房里用苹果平板 iPad Pro 11 英寸（妙控键盘 Magic Keyboard）解决二叉树问题/Evaluate Binary Tree。

本文一共 1152 个汉字, 你数一下对不对.

娃开始每天都在刷力扣, 他长大以后想当软件工程师. (AMP 移动加速版本)