liangbm3's blog

Debug 记录：一个缺失的“\0”和一个意外的“%”引发的挂死

Thu, 27 Nov 2025 00:00:00 GMT

在最近的实习过程中，遇到了一个上线模块的挂死问题，经排查发现这是一次由数据源头污染、内存越界读取以及格式化字符串漏洞三者巧合叠加引发的教科书级 Crash。这里记录一下这个问题的发现与解决过程。

1. 案发现场

模块挂死，我拿到的是一个 core dump 文件，使用 gdb 查看崩溃堆栈，主要内容如下：

[Current thread is 1 (Thread 0xffff8effd090 (LWP 9372))]
(gdb) bt
#0  raise (sig=6) ...
#1  <signal handler called>
#2  __GI_raise (sig=sig@entry=6) ...
#3  0x0000ffffa117c974 in __GI_abort () at abort.c:79
#4  0x0000ffffa11b572c in __libc_message ...
#5  0x0000ffffa11b5778 in __GI___libc_fatal (message=0xffffa12705d0 "*** %n in writable segment detected ***\n") at ../sysdeps/posix/libc_fatal.c:191
#6  0x0000ffffa1191288 in _IO_vfprintf_internal (format=... "[tte_app] event_id: ...LK6ADAE45RB756122% not found...\n", ...) at vfprintf.c:1642
...
#14 0x0000aaaadfe70f48 in tte::OnboardServiceApp::flQueryRecordVoiceCallback ...

重点是 frame #5 的错误信息：%n in writable segment detected，查阅资料发现，这是 Linux glibc 的一种安全保护机制。它意味着 printf 系列函数在解析格式化字符串时，发现在可写的内存段（堆或栈）中出现了 %n。由于 %n 会将已打印字符数回写到内存，极易被黑客用于覆盖栈数据，所以 glibc 检测到这种情况会直接让进程自杀。

2. 代码回溯

根据堆栈，崩溃发生在 flQueryRecordVoiceCallback 函数中。我找到了对应的业务代码：

// 崩溃所在的业务逻辑
int32_t OnboardServiceApp::flQueryRecordVoiceCallback(
    dcos::ConstMsg<sys_msgs::tte_service::VoiceStatusReq> const& req) {

  // ... 前面是初始化代码 ...

  // 直接强制转换原始字节流为 string
  std::string target_event_id =
      std::string(reinterpret_cast<const char*>(req->event_id));

  LOG_INFO(tte_header, "query event_id: %s\n", target_event_id.c_str());

  // 在锁内查找 event_id ...
  {
    std::lock_guard<std::mutex> l(resource_mutex_);
    for (auto it = process_tree_list_.begin(); it != process_tree_list_.end(); ++it) {
       // ... 省略查找逻辑 ...
       if (event_id == target_event_id) {
         // ... 找到后返回成功 ...
         return 0;
       }
    }
  }

  // [崩溃点] 未找到 ID，打印警告日志
  LOG_WARN(tte_header, "event_id: %s not found, returning error status\n",
           target_event_id.c_str());

  // ... 返回错误 ...
  return 0;
}

结合堆栈信息，崩溃点是在这个函数的 LOG_WARN 语句处，字符串里混入了一个诡异的 %，而且它后面紧接着 not found。

3. 根因分析

经过一步步分析，发现这里发生了三个致命巧合，导致了模块的崩溃。

3.1 第一环：缺失的终止符 `\0`

首先 target_event_id 里面出现 % 是意料之外的，正常来说应该只有数字和字母，VoiceStatusReq 结构体定义如下：

constexpr int32_t kEventIdSize{128};

struct VoiceStatusReq {
  uint8_t event_id[kEventIdSize];
} __attribute__((packed));

req->event_id 是一个固定大小的数组，发送方在填充这个数组时，没有在实际的 event_id 字符串末尾添加字符串终止符 \0。因此当我们直接将其转换为 std::string 时：

std::string target_event_id = std::string(reinterpret_cast<const char*>(req->event_id));

在接收端的代码中，std::string 的构造函数会从首地址一直往后读，直到读到内存里的某一个 0x00 为止。这一次刚好读到了栈上的垃圾数据。而在这些垃圾数据中，恰好有一个字节是 0x25（即 ASCII 码 %）。是的，发送方一直都没有做这个处理，其实接收方解析出来的 event_id 很多都是乱码，但是因为没有影响到业务，所以一直没被发现。

3.2 第二环：日志函数的“二次格式化”漏洞

拿到带有乱码的 target_event_id 后，程序执行到了最后的 LOG_WARN。日志库的封装大概是这样的：

void Log(dlog::LogLevel level, const std::string& prefix, const std::string& fmt, ...) {
  // 1. 第一步格式化：将用户参数拼接到 buffer
  char buffer[8192];
  va_list args;
  va_start(args, fmt);
  vsnprintf(buffer, sizeof(buffer), fmt.c_str(), args); // 这里生成了包含 "%" 的 buffer
  va_end(args);

  std::string formatted_msg = "[" + prefix + "] " + buffer;

  // 2. 第二步格式化：致命错误发生在这里
  // logger->Print 的底层是 printf 风格的变参函数
  // 这里直接把包含 "%" 的动态内容当成了 format string
  logger->Print(level, formatted_msg.c_str()); 
}

在 vsnprintf 完成拼接后，buffer 的内容变成了： ...LK6ADAE45RB756122% not found...。接着，logger->Print 被调用，它底层依赖 printf 逻辑。它拿这个 buffer 当作格式化字符串去解析。

3.3 第三环：致命的 `%n`

当 printf 解析到 ...% not found 时：

它看到了 %。
它忽略了后面的空格（在某些实现或复杂上下文中），或者因为字符串处于可写段引起了警觉。
它看到了 n。
% + n = %n。这是一个合法的格式控制符，意为“将已输出字符数量写入指针”。但由于这个字符串是在栈上动态生成的，glibc 判定这是一次格式化字符串攻击尝试，直接 Abort。

4. 意外发现

在审查日志库底层代码时，我还发现了一个可能导致架构级崩溃的隐患。原有的日志接口定义如下：

void Log(dlog::LogLevel level, const std::string& prefix, const std::string& fmt, ...) {}

C++ 标准明确规定：传递给 va_start 的最后一个固定参数如果是引用类型，则是未定义行为。虽然在 x86 上可能侥幸能跑，但在 ARM64 等架构下，这会导致 va_list 指针计算错误，无法获取后续参数，甚至导致野指针访问。

5. 问题修复

首先是修复日志库的格式化漏洞，永远不能信任动态拼接的字符串，必须显式指定格式：

// logger->Print(level, buffer); 错误
logger->Print(level, "%s", buffer);// 正确

同时将日志接口的 fmt 参数类型从 const std::string& 改为 const char*，确保 va_start 行为符合标准。

在业务层，不能假设网络发来的数据一定以 \0 结尾，需要限制一下读取的最大长度：

size_t len = strnlen(reinterpret_cast<const char*>(req->event_id), kEventIdSize);
std::string target_event_id(reinterpret_cast<const char*>(req->event_id), len);

6. 总结

这个 LOG_WARN 的崩溃，实际上是一个完美的连锁反应：

发送端少发一个 0。
接收端越界读取到了 %。
日志库错误地对内容进行了二次解析。
乱码 % 恰好碰上了固定文案里的 n。

这四个环节缺一不可，才导致了这个崩溃。因此在日常的开发中，要建立防御性编程的意识，不要信任网络包，不要信任内存里的数据，更不要把用户输入直接传给 printf。

Effective C++: 避免遮掩继承而来的名称

Sat, 25 Oct 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

这是 Effective C++ 的第 33 个条款，Avoid hiding inherited names，中文翻译为：避免遮掩继承而来的名称。

在 C++ 中，名称遮蔽指的是在内层作用域中声明的名称，会遮掩外层作用域中的同名名称。例如：

int x = 10; // Global 作用域

void someFunc() {
    double x = 5.0; // local 作用域
    std::cin >> x;    // 读取的是 local 变量 double x
                      // global 作用域的 int x 在这里被遮掩了
}

继承关系也可以看作一种作用域嵌套，Derived (派生类) 的作用域嵌套在 Base (基类) 的作用域中。继承中的名称遮蔽规则为当派生类定义了一个与其基类同名的成员（无论是成员变量还是成员函数）时，这个派生类成员会遮掩掉基类中所有同名的成员。注意：

遮掩所有同名成员：只要名称相同，基类中所有同名成员（即使它们是不同参数列表的重载函数）都会被遮掩。
与参数和 virtual 无关：遮掩规则只看名称，不看函数的参数列表、返回类型或是否为 virtual。

文中举了一个具体的例子：

class Base {
public:
    virtual void mf1() = 0;
    virtual void mf1(int x); // mf1 被重载
    
    void mf3();
    void mf3(double x); // mf3 被重载
    ...
};

class Derived : public Base {
public:
    virtual void mf1(); // 重写(override)了 Base::mf1()
    void mf3();         // 定义了 Derived::mf3()
    ...
};

// --- 客户端代码 ---
Derived d;
int x = 10;

d.mf1();   // 没问题, 调用 Derived::mf1()
d.mf1(x);  // 编译错误
d.mf3();   // 没问题, 调用 Derived::mf3()
d.mf3(x);  // 编译错误 (x 会被隐式转换为 double)

在上面的例子中，Derived 类中的 mf1() 和 mf3() 成员函数分别遮掩了 Base 类中所有同名的重载版本。因此，尝试调用 d.mf1(x); 和 d.mf3(x); 会导致编译错误，因为编译器找不到匹配的函数。在 public 继承下，这几乎总是不是我们想要的行为。public 继承意味着 "is-a" (是一种) 关系，派生类理应继承基类的所有接口。名称遮掩破坏了这种关系。

对于这个问题，主要有两种解决方法：

使用 using 声明。使用 using 声明可以将基类中所有同名的成员拉到派生类的作用域中，这是最常用且推荐的方法。

class Derived : public Base {
public:
    // 将 Base 中所有名为 mf1 的成员引入 Derived 的 public 作用域
    using Base::mf1; 
    
    // 将 Base 中所有名为 mf3 的成员引入 Derived 的 public 作用域
    using Base::mf3; 

    virtual void mf1(); // 依然重写 Base::mf1()
    void mf3();         // 重载(overload)了 Base::mf3() 和 Base::mf3(double)
    ...
};

// --- 客户端代码 (现在可以正常工作) ---
Derived d;
int x = 10;

d.mf1();   // 没问题, 调用 Derived::mf1()
d.mf1(x);  // 没问题，调用 Base::mf1(int)

d.mf3();   // 没问题, 调用 Derived::mf3()
d.mf3(x);  // 没问题，调用 Base::mf3(double)

using Base::mf1; 告诉编译器，把 Base 中所有叫 mf1 的东西都看作 Derived 作用域的一部分。现在 Derived 的作用域中同时有了 Base::mf1()、Base::mf1(int) 和 Derived::mf1()。根据C++的重载和重写规则：Derived::mf1() 重写了 Base::mf1()。Base::mf1(int) 依然可见，成为 Derived 接口的一部分。mf3 同理。

在某些特殊情况下，例如不想继承基类的所有重载版本（比如在 private 继承中，using 声明会使基类成员在派生类中变为 public），你可以使用转交函数。转交函数是派生类中定义的一个内联函数，它只是简单地调用它想继承的那个基类版本。

class Base {
public:
    virtual void mf1(int x);
    ...
};

// 假设我们只想暴露 mf1(int) 版本
class Derived : public Base {
public:
    // 只重写无参数版本
    virtual void mf1() { ... } 
    
    // 用转交函数“继承” mf1(int)
    void mf1(int x) {
        Base::mf1(x); // 显式调用 Base 的版本
    }
};

Effective C++: 确定你的 public 继承塑模出 is-a 关系

Sat, 25 Oct 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

这是Effective C++的第 32 条款，Make sure public inheritance models "is-a"，中文翻译为：确定你的 public 继承塑模出 is-a 关系。

这是 C++ 面向对象编程中非常重要的一条规则，它强调 C++ 中的 public 继承，其唯一的含义就是 "is-a" 关系。当我们写下 class Derived : public Base { ... }; 时，即是在向编译器和所有阅读代码的人做出一个承诺：每一个 Derived 类型的对象同时也是一个 Base 类型的对象。

这个承诺意味着，所有适用于 Base 对象的行为和属性，也必须同样适用于 Derived 对象。这通常被称为Liskov 替换原则 (Liskov Substitution Principle, LSP)。即如果程序中任何地方需要一个 Base 对象，都可以用一个 Derived 对象去替换它，而程序的行为不应该有任何“意外”的改变。

示例：

class Person { ... };
class Student : public Person { ... }; // 学生 "is-a" 人

void eat(const Person& p); // 任何人都会吃饭
void study(const Student& s); // 只有学生才到校学习

Person p;
Student s;

eat(p); // 正确
eat(s); // 正确，因为学生也是人
study(s); // 正确
// study(p); // 错误，并非所有人都是学生

文中作者还举了两个经典违法 LSP 的例子。

第一个例子如下：

class Bird {
public:
    virtual void fly();
};

class Penguin : public Bird { ... }; // 糟糕的设计！

从分类学的角度，企鹅是一种鸟，所以 class Penguin : public Bird { ... } 看起来很正常。但是如果为 Bird 定义一个 fly()方法，这个继承关系承诺了企鹅会飞，但我们都知道这是错误的，违反了 "is-a" 原则。对于这种错误的设计，文中提到了两种修复方法：

在 Penguin 中重新定义 fly() 并让它报错。
```
virtual void fly() {
    throw "企鹅不会飞！"; // 这是一种糟糕的运行时错误
}
```
但这是一个坏主意，因为一个设计层面的逻辑错误，推迟到了运行时才暴露出来。好的设计应该尽可能在编译期就防止错误。

更合理的继承体系，因为鸟这个概念本身不应该和会飞绑定。

class Bird {
    // ... 关于鸟的通用属性，比如有羽毛、是卵生等
    // 没有 fly() 函数
};

class FlyingBird : public Bird {
public:
    virtual void fly();
};

class Penguin : public Bird {
    // ... 企鹅特有的属性
};

这个设计更加精确。Penguin is-a Bird，FlyingBird is-a Bird。这个模型是正确的，因为它没有做出任何错误的承诺。

第二个例子是正方形与矩形的陷阱。从数学直觉上，正方形是一种特殊的矩形。所以 class Square : public Rectangle 似乎完全没有问题。但如果从行为上去分析，假设有一个 Rectangle 类：

class Rectangle {
public:
    virtual void setWidth(int newWidth);
    virtual void setHeight(int newHeight);
    int width() const;
    int height() const;
    ...
};

Rectangle 的一个核心行为是：它的长和宽可以被独立修改。假设有一个函数依赖于这个行为：

void makeBigger(Rectangle& r) {
    int oldHeight = r.height();
    r.setWidth(r.width() + 10);
    // 我们断言：修改宽度不应该影响高度
    assert(r.height() == oldHeight);
}

如果我们让 Square 公开继承 Rectangle：

class Square : public Rectangle { ... };

为了维持“正方形”的特性（长宽必须相等），Square 类的 setWidth 和 setHeight 必须被特殊实现，比如：

void Square::setWidth(int newWidth) {
    // 为了保持正方形特性，必须同时修改长和宽
    Rectangle::setWidth(newWidth);
    Rectangle::setHeight(newWidth);
}

当我们把一个 Square 对象传给 makeBigger 函数时：

Square s;
s.setWidth(10); // 此时 s 的长和宽都是10
makeBigger(s);  // s "is-a" Rectangle，所以编译通过

在 makeBigger 内部，oldHeight 被记录为 10。s.setWidth(20) 被调用。根据 Square 的实现，这会把 s 的宽和高都设置成 20。assert(s.height() == oldHeight) 会被触发，因为 s.height() 现在是 20，而 oldHeight 是 10。因此这种继承关系是错误的。

Effective C++: 成对使用 new 和 delete 时要采取相同形式

Thu, 23 Oct 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

这是 Effective C++ 的第 16 个条款，Use the same form in corresponding uses of new and delete，中文翻译为：成对使用 new 和 delete 时要采取相同形式。

这个条款的核心是 new 和 delete 的形式必须匹配。

如果你使用 new 来分配单个对象，就必须使用 delete 来释放。
如果你使用 new[] 来分配对象数组，就必须使用 delete[] 来释放。

之所以要怎么做，是因为编译器需要知道要为多少个对象调用析构函数。当使用 new 和 delete 时，底层会发生两件事：

内存的分配/释放 (通过 operator new 和 operator delete 函数)。
对象的构造/析构 (通过构造函数和析构函数)。

对于单个对象：

std::string* ptr1 = new std::string("hello");
// ...
delete ptr1;

new 分配足够一个 std::string 对象的内存，并在这块内存上调用 std::string 的构造函数。delete 对 ptr1 指向的对象调用 std::string 的析构函数，然后释放内存。这里 delete 明确知道只需要调用一次析构函数。

对于对象数组：

std::string* ptr2 = new std::string[3];
// ...
delete[] ptr2;

new[]:分配能容纳 3 个 std::string 对象的内存，并依次调用 3 次默认构造函数。delete[] 依次对这 3 个对象调用析构函数（通常是按与构造相反的顺序），然后释放整个内存块。

两者的关键区别在于内存布局。当使用 new[] 分配一个数组时，编译器会在分配的内存块中（通常是在指针返回的地址之前）额外存储数组的大小。当调用 delete[] 时，它会首先查找这个隐藏的 "数组大小" 记录，从而得知需要调用多少次析构函数。当调用 delete 时，它会假定只有一个对象，不会去查找这个大小，因此只会调用一次析构函数。

两者混用会导致未定义行为，即程序可能会崩溃、产生错误结果、或者表面上看起来正常运行但实际上已经造成了资源泄漏或内存损坏。

用 delete 释放数组：只会调用第一个对象的析构函数，其他对象的析构函数不会被调用，导致资源泄漏。
用 delete[] 释放单个对象：delete[] 会试图在指向的内存块之前读取一个 "数组大小"。但那里并没有存储这个信息，它会读取到一块无意义的数据。这可能会导致它尝试在一个完全错误的位置上执行循环，调用若干次析构函数，最终几乎肯定会损坏内存，导致程序崩溃。

在书中，作者还提到了一个常见的陷阱，即 typedef 可能会隐藏数组的本质，使得我们更容易犯错：

typedef std::string AddressLines[4]; // AddressLines 是一个包含4个string的数组类型

std::string* pal = new AddressLines; // 看起来像是分配单个对象，
                                     // 但实际上等价于 new std::string[4]
delete[] pal; // 正确
// delete pal;   // 错误！将导致资源泄漏

因此，最佳实践为：不要对数组类型使用 typedef 或 using，以避免混淆。

Effective C++: 以独立语句将 newed 对象置入智能指针

Thu, 23 Oct 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

这是 Effective C++ 的第 17 个条款，Store newed objects in smart pointers in standalone statements，中文翻译为：以独立语句将 newed 对象置入智能指针。

文章举了一个经典的例子来说明这个规则的重要性：

// 假设有这两个函数
int priority();
void processWidget(std::shared_ptr<Widget> pw, int priority);

如果使用这种看起来很紧凑的调用方式：

processWidget(std::shared_ptr<Widget>(new Widget()), priority()); // 危险！可能导致内存泄漏

这一行代码是非常危险的，因为 C++ 编译器拥有重新排列函数参数求值顺序的自由。在 processWidget 被真正调用之前，编译器必须完成三项工作：

执行 new Widget()，在堆上创建一个 Widget 对象。
调用 priority() 函数，获取一个 int 结果。
调用 std::shared_ptr 的构造函数，用 new Widget() 返回的原始指针来创建一个智能指针。

C++ 标准只保证 new Widget() 一定在 std::shared_ptr 的构造函数调用之前执行，但对于 priority() 的调用时机，标准并没有规定。这意味着，编译器可能会选择以下这个危险的执行顺序：

new Widget()：在堆上成功创建了一个 Widget 对象，一个指向它的原始指针被生成。
priority()：接着执行这个函数。
std::shared_ptr 构造函数：最后才用第 1 步的原始指针去构造智能指针。

按照上面这个顺序，如果在第二步，即 priority() 函数内部抛出了一个异常。根据 C++ 的异常处理机制，函数调用栈会开始回滚，这时第一步中由 new Widget() 创建的那个原始指针将会丢失，同时第三步 std::shared_ptr 的构造函数永远也不会执行。最终造成的结果是丢失了唯一指向堆上 Widget 对象的指针。这块内存再也无法被 delete，造成了内存泄漏。

我们本想用智能指针来防止资源泄漏，但在这个执行顺序下，资源在被智能指针接管之前就因为异常而泄漏了。

对于这个问题的解决方案，也就是这个条款所强调的，要用一条独立的语句完成智能指针的初始化：

// 安全的做法
std::shared_ptr<Widget> pw(new Widget()); // 第1步：创建对象并立刻用智能指针管理它

processWidget(pw, priority());            // 第2步：将已创建好的智能指针和另一个参数传入函数

C++ 保证语句之间是按顺序执行的。第一行代码必须完全执行完毕，才会开始执行第二行。对于这种写法：

在第一行 std::shared_ptr<Widget> pw(new Widget()); 中。如果 new Widget() 失败（例如内存不足抛出 std::bad_alloc），pw 根本不会被创建，一切正常。如果 new Widget() 成功，那么返回的原始指针会立即被用来构造 pw。这个操作在一条语句内是不可分割的。此时，Widget 资源已经安全地被 pw 管理起来了。
程序执行第二行 processWidget(pw, priority());时。即使 priority() 抛出异常，栈回滚机制也会正确地销毁局部变量 pw。pw 的析构函数会负责 delete 它所管理的 Widget 对象，不会发生任何资源泄漏。

实际上，现代 C++ 提供了比直接使用 new 更好的工具来创建智能指针：std::make_unique 和 std::make_shared。使用 std::make_shared 可以完全避免上面讨论的问题，并且写法更简洁、更安全，甚至可能更高效。

// 最佳实践：使用 std::make_shared
processWidget(std::make_shared<Widget>(), priority()); // 完全安全，并且推荐！

之所以 std::make_shared 更好，是因为 std::make_shared 是异常安全的，它像一个函数调用，它在内部完成了对象的创建和智能指针的构造。编译器无法将 priority() 的调用插入到这两个操作之间，从而从根本上杜绝了资源泄漏的风险。还有一个更重要的原因是效率更高：std::shared_ptr 需要一个额外的“控制块”来存储引用计数等信息。

std::shared_ptr<Widget>(new Widget()) 通常会导致两次堆内存分配：一次为 Widget 对象（在 new 中），一次为控制块（在 shared_ptr 构造函数中）。
std::make_shared<Widget>() 则足够智能，它会进行一次大的堆内存分配，同时容纳 Widget 对象和控制块。这减少了内存分配的开销，性能更好。

Effective C++: 在资源管理类中提供对原始资源的访问

Mon, 20 Oct 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

这是 Effective C++ 的第 15 个条款，Provide access to raw resources in resource-managing classes，中文翻译为：在资源管理类中提供对原始资源的访问。

这个条款解决了一个非常实际的问题：我们已经接受了 RAII 是管理资源的最佳方式，但我们所写的代码需要和大量已有的、只认“原始资源”的 API 交互。例如：

std::shared_ptr<Investment> pInv(createInvestment());
int daysHeld(const Investment* pi); // 一个只接受裸指针的 API
daysHeld(pInv); // 编译错误！类型不匹配，pInv 不是 Investment*

RAII 对象（pInv）封装了并管理着原始资源（ Investment* 指针），但它本身并不是那个原始资源。因此，RAII 类必须提供一个“出口”，允许外界在需要时能够访问到它内部封装的那个原始资源。在书中，作者提到了两种常见的做法：

显式转换：提供一个专门的成员函数（通常命名为 get），让用户明确地调用它来获取原始资源。std::shared_ptr 和 std::unique_ptr 都提供了 get() 成员函数。
```
daysHeld(pInv.get()); // 正确！调用 get() 获取裸指针
```
对于我们自定义的 Font 类，也可以添加一个 get() 方法：
```
class Font {
public:
    FontHandle get() const { return f; } // 显式转换函数
    // ...
private:
    FontHandle f;
};

Font myFont(getFont());
changeFontSize(myFont.get(), newSize); // 用户需要明确调用 .get()
```
- 优点：代码意图非常明确。任何看到 .get() 的人都知道这里正在从一个管理类中取出其原始资源。这降低了误用的风险。
- 缺点：用户必须时刻记着在需要原始资源的地方调用 .get()。
隐式转换：通过 C++ 的类型转换运算符，可以让类对象可以自动地、不经指明地转换为原始资源类型。实现的方法是在类中定义一个类型转换运算符 operator T()，其中 T 是你希望转换的目标类型。
```
class Font {
public:
    operator FontHandle() const { return f; } // 隐式转换函数
    // ...
};

Font myFont(getFont());
changeFontSize(myFont, newSize); // 非常自然！myFont 自动转换为 FontHandle
```
- 优点：用户代码写起来非常自然流畅，就像直接使用原始资源一样。
- 缺点：方便是有代价的。隐式转换可能在你不期望的时候发生，导致难以发现的 bug。书中举了一个绝佳的例子：
```
Font f1(getFont());
FontHandle f2 = f1;
```
  程序员的意图可能是想创建一个 Font 的副本，但这里实际上触发了 operator FontHandle()，创建了一个原始句柄 f2。当 f1 被销毁时，它会释放字体资源，而 f2 此时就变成了一个悬空句柄，再使用它就会导致程序崩溃或未定义行为。
  智能指针的 operator* 和 operator-> 也是一种隐式转换，但它们被设计得相对安全，因为它们返回的是对象本身或其成员的引用/指针，而不是资源句柄的副本。

总的来说，安全性通常比便利性更重要，因此：

首选显式转换 (get 方法)。它让代码的意图更加清晰，并且可以有效避免由意想不到的类型转换所引起的严重错误。
谨慎使用隐式转换。虽然它能让客户代码更漂亮，但它带来的风险（如上述的悬空句柄问题）往往得不偿失。只有在确定这种转换在所有情况下都是安全且符合直觉时，才应该考虑提供它。

Effective C++: 以对象管理资源

Sun, 19 Oct 2025 00:00:00 GMT

这是 Effective C++ 的第 13 个条款，Using objects to manage resources，中文翻译为：以对象管理资源。

在 C++ 中，资源通常指哪些一旦用了它，将来就必须还回去的东西，比如文件句柄、网络连接、互斥锁、动态分配的内存等。以动态分配内存为例，使用 new 分配的内存必须用 delete 释放，否则就会发生内存泄漏。

在书中，作者举了这样一个例子：

// 一个生产 Investment 对象的工厂函数
Investment* createInvestment();

void f()
{
    Investment* pInv = createInvestment(); // 调用工厂函数，获得资源
    ... // 其他操作
    delete pInv; // 手动释放资源
}

这段代码的问题在于，如果中间的...部分发生了异常，或者函数有多个 return 路径、continue 或 goto 语句提前退出，那么 delete pInv 就可能永远不会被执行，从而导致资源泄漏（在这个例子中是内存泄漏）。手动管理资源是不可靠且危险的。

为了解决这个问题，C++ 提供了一种更安全的资源管理方式：资源获取即初始化（RAII, Resource Acquisition Is Initialization）。RAII 的核心思想是将资源的获取和释放绑定到对象的生命周期上。具体做法是：

在构造函数中获取资源：将资源（如动态分配的内存指针）封装在一个类中，在类的构造函数里完成资源的申请。
在析构函数中释放资源：在类的析构函数里执行资源的释放操作（如 delete）。

由于 C++ 语言保证，当一个对象离开其作用域时（无论是函数正常结束还是因为抛出异常），它的析构函数一定会被自动调用。这样一来，资源的释放就变成了自动行为，永远不会被遗漏。

在现代 C++ 中，标准库提供了许多 RAII 风格的类来管理各种资源。例如：

std::unique_ptr 和 std::shared_ptr：用于管理动态分配的内存。
std::lock_guard 和 std::unique_lock：用于管理互斥锁。
std::fstream：用于管理文件句柄。

通过使用这些 RAII 类，我们可以大大简化资源管理的代码，减少错误发生的可能性。

Effective C++: 在资源管理类中小心 copying 行为

Sun, 19 Oct 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

这是 Effective C++ 的第 14 个条款，Think carefully about copying behavior in resource-managing classes，中文翻译为：在资源管理类中小心 copying 行为。

当我们自己写一个 RAII 类时，比如书中提到的用于管理互斥锁的 Lock 类：

class Lock {
public:
    explicit Lock(Mutex* pm) : mutexPtr(pm) {
        lock(mutexPtr); // 在构造函数中获取资源（加锁）
    }
    ~Lock() {
        unlock(mutexPtr); // 在析构函数中释放资源（解锁）
    }
private:
    Mutex* mutexPtr;
};

这个基础的 Lock 类遵循了 RAII 原则，但是当我们复制一个 Lock 对象时，问题就来了：

Mutex m; // 一个互斥锁
{
    Lock m1(&m);    // m1 对 m 加锁
    Lock m2(m1);    // m2 是 m1 的一个副本。这里会发生什么？
} // m1 和 m2 在这里离开作用域，它们的析构函数被调用

如果我们没有手动定义拷贝构造函数的话，编译器会自动生成一个默认的拷贝构造函数，这个默认的拷贝构造函数只会进行浅拷贝操作，即简单地复制成员变量的值。在这个例子中，m2 会得到和 m1 相同的 mutexPtr 指针，这意味着当 m1 和 m2 离开作用域时，它们都会尝试解锁同一个互斥锁。这会导致未定义行为，因为同一个互斥锁被解锁了两次。

因此，作者提到，当设计一个 RAII 类时，对于“复制”操作，通常有以下四种选择：

禁止复制：这是最简单、也常常是最安全的选择。如果复制一个资源句柄没有意义（比如锁），或者会带来问题，那就直接禁止它。
- 适用场景：资源的逻辑本身就不支持被复制或共享，例如 std::unique_ptr。
- 实现方式：通过将拷贝构造函数和拷贝赋值运算符声明为私有（C++11 之前）或删除（C++11 及以后）来禁止复制。
```
class Lock {
public:
    // ...
    Lock(const Lock&) = delete;
    Lock& operator=(const Lock&) = delete;
private:
    // ...
};
```
引用计数：允许多个对象共享同一个底层资源，并记录“使用者”的数量。只有当最后一个使用者被销毁时，资源才被真正释放。
- 适用场景：需要共享资源所有权的场景，例如 std::shared_ptr。
- 实现方式：最简单的方法是在 RAII 类内部使用一个 std::shared_ptr 来持有资源。shared_ptr 可以接受一个自定义删除器，这让它不仅能管理内存，还能管理任何资源。
```
class Lock {
public:
    explicit Lock(Mutex* pm)
        : pMutex(pm, unlock) // 使用 shared_ptr，并提供 unlock 作为删除器
    {
        lock(pMutex.get());
    }
    // 不需要手动写析构函数，shared_ptr 会自动管理！
private:
    std::shared_ptr<Mutex> pMutex;
};
```
当最后一个 Lock 对象被销毁时，它内部的 shared_ptr 的引用计数会变为 0，此时它会自动调用我们提供的 unlock 函数来释放锁。
深拷贝：在复制对象时，也完整地复制一份底层资源。这样每个对象都拥有一份独立的、内容相同的资源。
- 适用场景：当资源本身可以被安全、完整地复制时。例如，一个管理动态字符数组的字符串类。
- 实现方式：手动实现拷贝构造函数和拷贝赋值运算符，在其中创建新资源并复制内容。
```
// 伪代码示例
String(const String& other) {
    // 分配新内存
    // 复制 other 中的字符串内容到新内存
}
```

转移所有权：在复制时，将底层资源的所有权从源对象“转移”到目标对象，源对象则不再拥有该资源（通常变为空）。

适用场景：需要严格的独占所有权，但又希望能够转移它。例如 std::unique_ptr。
实现方式：在 C++11 之后，通过实现移动构造函数和移动赋值运算符来完成。

class UniqueResource {
public:
    UniqueResource(Resource* res) : resourcePtr(res) {}
    // 移动构造函数
    UniqueResource(UniqueResource&& other) noexcept
        : resourcePtr(other.resourcePtr) {
        other.resourcePtr = nullptr; // 转移所有权
    }
    // 移动赋值运算符
    UniqueResource& operator=(UniqueResource&& other) noexcept {
        if (this != &other) {
            release(); // 释放当前资源
            resourcePtr = other.resourcePtr;
            other.resourcePtr = nullptr; // 转移所有权
        }
        return *this;
    }
private:
    Resource* resourcePtr;
    void release() {
        if (resourcePtr) {
            // 释放资源
        }
    }
};

Effective C++: 为多态基类声明虚析构函数

Sat, 18 Oct 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

这是Effective C++的第 7 条款，Declare destructors virtual in polymorphic base classes，中文翻译为：为多态基类声明虚析构函数。

这个条款是用来解决一个非常具体且危险的问题：当通过基类指针删除派生类对象时，如果基类的析构函数不是虚函数，派生类的析构函数将不会被调用，导致资源泄漏和未定义行为。

以下代码为例：

// 基类
class TimeKeeper {
public:
    TimeKeeper();
    ~TimeKeeper(); // 注意：这是一个非虚 (non-virtual) 析构函数
    // ...
};

// 派生类
class AtomicClock : public TimeKeeper { ... };

// 工厂函数，返回一个指向派生类对象的基类指针
TimeKeeper* getTimeKeeper() {
    return new AtomicClock();
}

// 客户端代码
TimeKeeper* ptk = getTimeKeeper();
// ... 使用 ptk ...
delete ptk; // 危险！问题就在这里！

当调用 delete ptk; 时，由于 TimeKeeper 的析构函数不是虚函数，只有 TimeKeeper 的析构函数会被调用，而 AtomicClock 的析构函数不会被调用。这会导致 AtomicClock 中分配的资源（如动态内存、文件句柄等）无法正确释放，进而引发资源泄漏和未定义行为。而解决方法就是将基类的析构函数声明为虚函数：

class TimeKeeper {
public:
    TimeKeeper();
    virtual ~TimeKeeper(); 
    // ...
};

但是作者又指出，无端地将所有类的析构函数声明为虚函数也是错误的做法。

性能与成本：最直接和最主要的原因是性能和内存成本的考虑，当为一个类添加虚函数时，会给该类的每个对象引入一个虚函数指针(vptr)，这会导致对象体积的增大，文中举了一个非常形象的例子：一个用于表示二维空间点坐标的 Point 类，原本可能只包含两个 int，在64位系统上占用64位（8字节）。一旦为其添加了 vptr，整个对象的体积可能会增大50%~100%，达到96位（12字节）甚至128位（16字节）。另一方面，引入 vptr 会破坏对象的内存布局，使其不再是纯粹的数据集合，这样的对象将“不再可能把它们传递至（或接收自）其他语言所写的函数”，不再具有移植性。
设计意图：一个类不含任何虚函数，通常是在明确地表示“它并不意图被用作一个基类”，或者至少不是一个“多态基类”。文中用 std::string 举例。std::string 没有任何虚函数，包括析构函数。这清楚地表明了它的设计者不希望用户继承它并进行多态操作。如果你错误地这样做了（例如，class SpecialString : public std::string），并且通过 std::string 指针去删除 SpecialString 对象，就会导致未定义行为。

文中还提到了纯虚析构函数，有时候你想让一个类成为抽象基类（不能被实例化），但这个类里又恰好没有任何其他适合声明为纯虚的函数，这时候就可以将析构函数声明为纯虚析构函数：

class AWOW { // Abstract w/o Virtuals
public:
    virtual ~AWOW() = 0; // 声明一个纯虚析构函数
};

需要注意的是，纯虚析构函数必须在类外进行定义，即使它是纯虚的，因为在派生类对象被销毁时，基类的析构函数仍然需要被调用：

AWOW::~AWOW() { } // 必须提供，哪怕是空的

Effective C++: 视C++为一个语言联邦

Sat, 18 Oct 2025 00:00:00 GMT

这是Effective C++的第一个条款，View C++ as a federation of languages，中文翻译为：视C++为一个语言联邦。

对于这个条款的理解，可以从 C++ 的历史发展来看。

C++ 的故事始于 1979 年，在美国新泽西州的贝尔实验室（Bell Labs）。一位名叫本贾尼·斯特劳斯特卢普 (Bjarne Stroustrup) 的丹麦计算机科学家，希望将他博士期间使用的 Simula 语言的“类”和面向对象思想，与 C 语言的高效和底层控制能力结合起来。最初的产物，被称为“C with Classes”。主要是在C的基础上增加了：

类（Classes）
继承（Inheritance）
内联函数（Inline Functions）
默认参数（Default Arguments）

到了1983年，C with Classes 发展成为 C++，在这个时期，C++ 加入了许多至今仍是核心的特性：

虚函数（Virtual Functions）
函数重载（Function Overloading）
引用（References）
new 和 delete 操作符
模板（Templates）

随着 C++ 被越来越广泛地使用，不同的编译器厂商实现了各自的版本，导致了代码的可移植性问题。为了解决这个问题，一个标准化的进程启动了。1998年，第一个 C++ 标准发布，通常称为 C++98。这是一个极其重要的版本，它标志着 C++ 从一门“语言”正式成为一个有国际标准的“工业级语言”。C++98 主要贡献：

语言核心的规范化
标准库的诞生

2011年至今，C++经历了多次重大更新：

C++11：被誉为“现代C++”的开端，引入了自动类型推导（auto）、范围for循环（range-based for loops）、智能指针（smart pointers）、右值引用（rvalue references）、lambda表达式、并发编程支持等。
C++14：对C++11的补充和改进，增加了泛型lambda、auto返回类型推导等特性。
C++17：引入了结构化绑定（structured bindings）、std::optional、std::variant等。
C++20：带来了概念（concepts）、范围（ranges）、协程（coroutines）、模块（modules）等重大特性。
C++23：继续在语言和库方面进行改进，增强了对现代编程范式的支持。例如 std::print 、std::expect 等。

通过回顾 C++ 的发展历程，我们可以清晰地看到 C++ 并非一成不变的单一语言，而是一个不断演进、融合多种编程范式和特性的“语言联邦”。每一个版本的更新都引入了新的概念和工具，使得 C++ 能够适应不同的编程需求和挑战。

书中，作者提出，可以把 C++ 看成四个子语言，每个子语言都有自己的一套规则、惯例和最佳实践。当你从一个子语言切换到另一个时，高效编程的策略可能也需要随之改变。

C：这部分完全继承了 C 的所有特性，是 C++ 的基石，包括：
- 核心语法：块（blocks）、语句（statements）、预处理器（preprocessor）、内置数据类型（built-in data types）、指针（pointers）、数组（arrays）等。
- 编程范式：面向过程
- 高效编程规则：在 C 的世界里，一切原始且高效，需要手动管理内存，注重性能和资源利用。
Object-Oriented C++：这部分也就是 C with Classes 所诉求的，主要围绕类和对象来展开，包括：
- 核心概念：类（classes）、封装（encapsulation）、继承（inheritance）、多态（polymorphism）、构造函数（constructors）和析构函数（destructors）。
- 编程范式：面向对象编程（OOP）
- 高效编程规则：在这个子语言中，关注点转向了设计模式、对象生命周期管理、虚函数的使用等。
Template C++：这是 C++ 泛型编程部分，运行我们编写不依赖具体类型的代码，提高代码的复用性，包括：
- 核心概念：模板（templates）、模板特化（template specialization）、模板元编程（template metaprogramming）。
- 编程范式：泛型编程
- 高效编程规则：模板元编程是这个语言的高阶玩法，可以将原本在运行时完成的工作提前到编译阶段，意味着某些运行时错误可以在编译时发现，能够生成极其高效的代码。
STL：STL是一个基于模板构建、高度协同的程序库，包括：
- 核心组件：容器（containers）、迭代器（iterators）、算法（algorithms）、函数对象（function objects）。
- 编程范式：基于容器、迭代器和算法的编程
- 高效编程规则：STL有一套自己的惯例，例如使用迭代器遍历容器而不是指针，优先使用标准算法而不是手写循环等。

因此，当使用 C++ 编程的时候，理解并区分这四个子语言是非常重要的。每个子语言都有其独特的规则和最佳实践，只有正确地应用这些规则，才能编写出高效、可靠的 C++ 代码。

C++ 中使用 SQLite3 API 的经典流程

Thu, 16 Oct 2025 00:00:00 GMT

1. 核心概念

在使用 C++ API 之前，需要理解 SQLite3 的几个核心对象和函数：

sqlite3: 代表一个打开的数据库连接的句柄（handle）。所有针对该数据库的操作都需要这个对象。
sqlite3_stmt: 代表一个已经编译（prepared）的 SQL 语句。这是执行复杂查询和防止 SQL 注入的关键。
返回码: SQLite3 的几乎所有函数都会返回一个整型状态码，例如 SQLITE_OK 表示成功，SQLITE_ERROR 表示通用错误，SQLITE_BUSY 表示数据库被锁定等。检查这些返回码是保证程序健壮性的关键。

2. 经典使用流程

2.1 包含头文件和定义必要变量

int main() {
  sqlite3 *db; // 数据库句柄
  char *errMsg = nullptr;
  int rc; // 返回值
  //...其他代码
 }

2.2 打开或创建数据库

函数: int sqlite3_open(const char *filename, sqlite3 **ppDb)

作用: 打开一个数据库连接。

参数:

filename: 数据库文件的路径。
ppDb: 一个指向 sqlite3* 指针的指针，函数会把创建的数据库句柄写入这里。

// 创建或打开数据库
rc = sqlite3_open("test.db", &db);
if (rc) {
  std::cerr << "Can't open database: " << sqlite3_errmsg(db) << std::endl;
  return rc;
} else {
  std::cout << "Opened database successfully" << std::endl;
}

sqlite3_errmsg(db) 是一个非常有用的函数，它可以获取最近一次操作失败的错误信息。

2.3 执行SQL语句（非查询类）

对于不需要返回结果集的 SQL 语句，比如 CREATE TABLE, INSERT, UPDATE, DELETE，最简单的方式是使用 sqlite3_exec()。

函数: int sqlite3_exec(sqlite3 *db, const char *sql, int (*callback)(void*,int,char**,char**), void *arg, char **errmsg)

作用: 一次性执行一个或多个 SQL 语句。

参数:

db: 数据库句柄。
sql: 要执行的 SQL 字符串。
callback: 回调函数，每当查询产生一行结果时被调用（对于非查询语句，设为 NULL）。
arg: 传递给回调函数的第一个参数。
errmsg: 用于存放错误信息的指针。

// 创建一张表
const char *sql_create_table = "CREATE TABLE IF NOT EXISTS USERS("
                             "ID INT PRIMARY KEY     NOT NULL,"
                             "NAME           TEXT    NOT NULL,"
                             "AGE            INT     NOT NULL);";
rc = sqlite3_exec(db, sql_create_table, nullptr, nullptr, &errMsg);
if (rc != SQLITE_OK) {
  std::cerr << "SQL error: " << errMsg << std::endl;
  sqlite3_free(errMsg); // 释放错误信息内存
} else {
  std::cout << "Table created successfully" << std::endl;
}
// 插入数据
const char *sql_insert =
  "INSERT INTO USERS (ID,NAME,AGE) VALUES (1, 'Alice', 25);"
  "INSERT INTO USERS (ID,NAME,AGE) VALUES (2, 'Bob', 30);";
rc = sqlite3_exec(db, sql_insert, nullptr, nullptr, &errMsg);
if (rc != SQLITE_OK) {
  std::cerr << "SQL error: " << errMsg << std::endl;
  sqlite3_free(errMsg); // 释放错误信息内存
} else {
  std::cout << "Records created successfully" << std::endl;
}

2.4 执行查询并处理结果

对于 SELECT 查询，虽然也可以使用 sqlite3_exec 配合回调函数，但更经典和推荐的做法是使用 prepare - step - finalize 流程。这种方式更灵活、更安全（可以防止 SQL 注入），并且效率更高。

2.4.1 准备SQL语句

使用 sqlite3_prepare_v2() 将 SQL 语句编译成一个字节码对象 (sqlite3_stmt)。

函数: int sqlite3_prepare_v2(sqlite3 *db, const char *zSql, int nByte, sqlite3_stmt **ppStmt, const char **pzTail)

作用: 编译 SQL 语句，为执行做准备。

参数：

db: 数据库连接句柄
zSql: 要编译的SQL语句字符串
bByte:SQL字符串的字节长度，如果为 -1 SQLite 会自动计数
ppStmt: 输出参数，用于接收编译后的语句句柄
pzTail: 输出参数，指向SQL字符串中未被处理的部分，如果SQL字符串中包含多个语句，会返回第一个语句后剩余的部分，如果只有一个语句或者不关心剩余的部分，可以传入nullptr

sqlite3_stmt *stmt; // 语句句柄
const char *sql_select = "SELECT ID, NAME, AGE FROM USERS WHERE AGE > ?;";
// 准备SQL语句
rc = sqlite3_prepare_v2(db, sql_select, -1, &stmt, nullptr);
if (rc != SQLITE_OK) {
  std::cerr << "Failed to prepare statement: " << sqlite3_errmsg(db) << std::endl;
  sqlite3_close(db);
  return rc;
}

2.4.2 绑定参数

如果 SQL 语句中使用了占位符 (?)，需要使用 sqlite3_bind_*() 系列函数来绑定具体的值。这可以有效防止 SQL 注入攻击。

// 绑定整数
int sqlite3_bind_int(sqlite3_stmt*, int, int);

// 绑定64位整数
int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);

// 绑定双精度浮点数
int sqlite3_bind_double(sqlite3_stmt*, int, double);

// 绑定空值
int sqlite3_bind_null(sqlite3_stmt*, int);

// 绑定文本字符串
int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int, void(*)(void*));

// 绑定二进制数据
int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int, void(*)(void*));

这一系列的函数第一个参数为语句句柄，第二个参数为占位符索引（从1开始），第三个参数为值，第四个参数为一个析构函数指针，用于指定字符串的生命周期类型。这个参数可以为SQLITE_STATIC和SQLITE_TRANSIENT

SQLITE_STATIC:
1. 含义: 向 SQLite 保证，传入的这个字符串 (zData) 的内存是静态的、全局的、或者至少在 sqlite3_stmt 整个生命周期内（直到 sqlite3_finalize 被调用）都是有效且不会改变的。
2. SQLite 的行为: 既然做了这个保证，SQLite 为了追求极致的性能，会直接使用传入的指针，而不会自己复制一份字符串数据。它只是持有了这个指针。
3. 风险: 如果传入了一个局部变量（比如一个函数内的 std::string.c_str() 或者一个栈上的字符数组），当函数返回后，这个局部变量被销毁，内存被释放。但 SQLite 里的语句句柄 stmt 还傻傻地存着那个已经无效的野指针。后面调用 sqlite3_step() 去执行它时，它会尝试读取一个无效的内存地址，从而导致未定义行为，通常表现为程序崩溃、数据损坏或奇怪的错误。
SQLITE_TRANSIENT:
1. 含义: 这个宏告诉 SQLite，传入的这个字符串 (zData) 是临时的、短暂的 (transient)，它的生命周期可能很短，在 sqlite3_bind_text 函数调用返回后可能就失效了。
2. SQLite 的行为: 收到这个信号后，SQLite 会变得很谨慎。它会在函数内部立即将字符串数据完整地复制一份，并由自己来管理这份拷贝的内存。这样，即使原始的字符串变量超出了作用域被销毁，也完全没关系，因为 SQLite 使用的是它自己的安全拷贝。
3. 代价: 需要一次额外的内存分配和数据拷贝，相比 SQLITE_STATIC 会有微小的性能开销。但它换来的是安全和省心。

int age_limit = 20;
rc = sqlite3_bind_int(stmt, 1, age_limit);
if (rc != SQLITE_OK) {
  std::cerr << "Failed to bind parameter: " << sqlite3_errmsg(db) << std::endl;
  sqlite3_finalize(stmt);
  sqlite3_close(db);
  return rc;
}

2.4.3 执行语句并逐行获取结果

使用 sqlite3_step() 来执行预处理语句。

函数: int sqlite3_step(sqlite3_stmt *pStmt)
作用: 执行一次编译好的 SQL 语句。
返回值:
- SQLITE_ROW: 表示成功获取了一行数据，可以提取结果。
- SQLITE_DONE: 表示所有行都已处理完毕。
- 其他错误码。

当 sqlite3_step() 返回 SQLITE_ROW 时，使用 sqlite3_column_*() 系列函数来获取当前行各个字段的值。

函数: sqlite3_column_int(), sqlite3_column_text(), sqlite3_column_double() 等。
作用: 获取查询结果中当前行的某一列数据。

// 循环执行step，逐行获取数据
while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
  int id = sqlite3_column_int(stmt, 0);
  const unsigned char *name = sqlite3_column_text(stmt, 1);
  int age = sqlite3_column_int(stmt, 2);
  std::cout << "ID: " << id << ", Name: " << name << ", Age: " << age << std::endl;
}
if (rc != SQLITE_DONE) {
  std::cerr << "Failed to execute statement: " << sqlite3_errmsg(db) << std::endl;
}

2.5 销毁语句句柄

查询结束后，必须使用 sqlite3_finalize() 来销毁 sqlite3_stmt 对象，释放资源。

函数: int sqlite3_finalize(sqlite3_stmt *pStmt)
作用: 销毁预处理语句对象，回收内存。

// 释放语句句柄
sqlite3_finalize(stmt);

2.6 关闭数据库

所有操作完成后，使用 sqlite3_close() 关闭数据库连接，释放所有与该连接相关的资源。

函数: int sqlite3_close(sqlite3 *db)
作用: 关闭数据库连接。

// 关闭数据库
sqlite3_close(db);

3. 总结

| 步骤 | 核心函数 | 主要作用 | | --- | --- | --- | | 1. 打开数据库 | sqlite3_open() | 获取数据库连接句柄 sqlite3* | | 2. 执行非查询SQL | sqlite3_exec() | 简单快速地执行 CREATE, INSERT 等操作| | 3. 准备查询 | sqlite3_prepare_v2() | 编译 SELECT 语句，获取语句句柄 sqlite3_stmt*| | 4. 绑定参数 | sqlite3_bind_*() | (可选) 为 ? 占位符安全地绑定值。 | | 5. 逐行执行 | sqlite3_step() | 在循环中调用，每次获取一行结果 (SQLITE_ROW)。 | | 6. 提取数据 | sqlite3_column_*() | 从当前行中按列索引提取数据。 | | 7. 终结语句 | sqlite3_finalize() | 释放语句句柄 sqlite3_stmt* 的资源。 | | 8. 关闭数据库 | sqlite3_close() | 释放数据库连接句柄 sqlite3* 的所有资源。 |

SQLite 踩坑记录

Wed, 15 Oct 2025 00:00:00 GMT

1. 问题背景

最近在实习中排查了一个相当棘手的 Bug，这里记录一下。这个Bug的表象是一个模块将 JSON 数据存入 SQLite 数据库后，再次读取出来时会发生数据损坏。

排查记录：

检查日志：首先查看了模块的日志，很快定位到了错误，程序在解析从数据库中读出的 JSON 字符串时抛出了异常。
打印原始数据：然后我直接打印了从数据库读出的原始字符串，发现内容要么是乱码，要么干脆是空的。
检查写入过程：我转头去检查数据写入时的日志，却发现一切正常，没有任何错误或警告信息。程序似乎认为它已经成功地将数据写入了数据库。
直击数据库：既然日志无法提供更多线索，我便使用命令行工具直接查询数据库。真相大白——数据库里存储的数据本身就是有问题的。这说明问题出在写入阶段，而不是读取或解析阶段。

经过层层排查，我最终锁定了一个在使用 SQLite C++ API 时非常经典、但也极易被忽视的“坑”。

2. 问题根源

最后排查出来的问题是sqlite3_bind_text()这个API使用错误。API的函数原型如下：

int sqlite3_bind_text(
  sqlite3_stmt *pStmt,
  int i,
  const char *zData,
  int nData,
  void (*xDel)(void*)
);

参数解释：

pStmt: 语句句柄。
i: 参数索引 (从1开始)。
zData: 要绑定的字符串数据。
nData: 字符串长度 (-1 表示自动计算)。
xDel: 这是一个析构函数指针，用于指定字符串 zData 的生命周期类型。

xDel 参数可以传入两个特殊的宏：

SQLITE_STATIC:
1. 含义: 向 SQLite 保证，传入的这个字符串 (zData) 的内存是静态的、全局的、或者至少在 sqlite3_stmt 整个生命周期内（直到 sqlite3_finalize 被调用）都是有效且不会改变的。
2. SQLite 的行为: 既然做了这个保证，SQLite 为了追求极致的性能，会直接使用传入的指针，而不会自己复制一份字符串数据。它只是持有了这个指针。
3. 风险: 如果传入了一个局部变量（比如一个函数内的 std::string.c_str() 或者一个栈上的字符数组），当函数返回后，这个局部变量被销毁，内存被释放。但 SQLite 里的语句句柄 stmt 还傻傻地存着那个已经无效的野指针。后面调用 sqlite3_step() 去执行它时，它会尝试读取一个无效的内存地址，从而导致未定义行为，通常表现为程序崩溃、数据损坏或奇怪的错误。
SQLITE_TRANSIENT:
1. 含义: 这个宏告诉 SQLite，传入的这个字符串 (zData) 是临时的、短暂的 (transient)，它的生命周期可能很短，在 sqlite3_bind_text 函数调用返回后可能就失效了。
2. SQLite 的行为: 收到这个信号后，SQLite 会变得很谨慎。它会在函数内部立即将字符串数据完整地复制一份，并由自己来管理这份拷贝的内存。这样，即使原始的字符串变量超出了作用域被销毁，也完全没关系，因为 SQLite 使用的是它自己的安全拷贝。
3. 代价: 需要一次额外的内存分配和数据拷贝，相比 SQLITE_STATIC 会有微小的性能开销。但它换来的是安全和省心。

3. 总结

在使用这个API的时候，应该根据数据的声明周期来选择正确的宏。

对于局部变量、临时拼接的字符串、std::string 对象等，它们的生命周期很短，必须使用 SQLITE_TRANSIENT。

std::string user_name = "Alice";
// 正确的做法：告诉 SQLite 这是临时数据，请它自己复制
sqlite3_bind_text(stmt, 1, user_name.c_str(), -1, SQLITE_TRANSIENT);

对于字符串字面量、全局变量、或能确保其生命周期超过 stmt 的数据，可以使用 SQLITE_STATIC 来获得一点性能优势。

// 字符串字面量是静态存储的，整个程序运行期间都有效
sqlite3_bind_text(stmt, 1, "Alice", -1, SQLITE_STATIC); // 这是安全的

4. 拓展

深入探究会发现，SQLite 的 sqlite3_bind_* 系列 API 在设计上体现了 C/C++ 核心的数据传递思想，主要分为两类：

传值
- sqlite3_bind_int()
- sqlite3_bind_double()
- sqlite3_bind_int64()
传指针
- sqlite3_bind_text()
- sqlite3_bind_blob()

对于传值，SQLite 接收到的是这个数字的副本。它会立即将这个副本存放到它自己管理的内存中（通常是 sqlite3_stmt 对象内部的某个字段）。这个过程非常快，因为整数和浮点数都是固定大小的、很小的数据类型。一旦函数调用完成，SQLite 已经拿到了它需要的值的拷贝。原来的变量之后是超出作用域被销毁，还是被修改，都与 SQLite 毫无关系了。SQLite 内部已经有了一个安全、独立的副本，所以不存在野指针或数据失效的风险。

对于传指针，SQLite 拿到的只是一个地址，它并不知道这个地址指向的内存能有效多久。这段内存是由调用者管理的。这就带来了我们之前讨论的问题：如果 SQLite 不复制，它就需要你保证这个地址在未来（sqlite3_step 执行时）依然有效。这就是 SQLITE_STATIC 的含义。如果 SQLite 自己复制，它就需要分配内存，然后把指针指向的数据拷贝过来。这样就安全了，但有性能开销。这就是 SQLITE_TRANSIENT 的含义。生命周期参数是必需的: 因为 C API 无法自动判断指针的生命周期，所以 SQLite 的设计者选择将这个决定权通过最后一个参数交还给开发者，让你明确告知它应该如何处理这个指针。

单源最短路径

Wed, 09 Jul 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

1. 简介

单源最短路径问题是图论中的一个非常经典的问题，它的目标是在一个带权的有向图或无向图中，找到从一个指定的“源”顶点到图中所有其他顶点的最短路径（路径上所有边的权重之和最小）。这个问题在实际生活中有很多重要的应用，比如网络路由、地图导航、通信网络优化等。

主要的单源最短路径算法主要有以下三个：

Dijkstra 算法：最著名和最常用的算法，但前提是图中所有边的权重都必须是非负的。
Bellman-Ford 算法：比 Dijkstra 算法更具普适性，可以处理带有负权重边的图。同时，它还能检测图中是否存在“负权环”。
SPFA 算法 (Shortest Path Faster Algorithm)：这是 Bellman-Ford 算法的一种优化版本，在很多情况下（特别是稀疏图）比 Bellman-Ford 更快，同样可以处理负权边和检测负权环。

2. Dijkstra 算法

Dijkstra 算法（迪杰斯特拉算法） 是一种贪心算法。它的核心思想是，每次都从“尚未确定最短路径”的顶点中，选择一个距离源点最近的顶点，并且认为这个顶点的最短路径已经确定，然后用这个顶点去更新其他相邻顶点的距离。

算法步骤如下：

初始化：
- 创建一个距离数组 dist，dist[i] 表示从源点 startNode 到顶点 i 的当前最短距离。将 dist[startNode] 初始化为 0，其他所有顶点的 dist 初始化为无穷大 (INF)。
- 创建一个优先队列 pq，并将 {0, startNode}（表示距离为0，顶点为 startNode）加入队列。优先队列会根据距离从小到大排序。
主循环：当优先队列不为空时，执行以下操作：
- 从优先队列中取出距离最小的顶点 u（以及其距离 d）。
- 如果 d 大于 dist[u]，说明已经有更短的路径到达 u 了（这个旧的、较长的路径信息是冗余的），直接跳过本次循环。
- 遍历 u 的所有邻接点 v（权重为 w），进行松弛操作：如果通过 u 到达 v 的路径比已知的到 v 的最短路径还要短（即 dist[u] + w < dist[v]），那么就更新 dist[v] 为 dist[u] + w，并将新的、更短的路径信息 {dist[v], v} 加入优先队列。
结束：循环结束后，dist 数组中就存储了从源点到所有其他顶点的最短路径长度。

C++ 代码实现如下：

#include <iostream>
#include <vector>
#include <queue>
#include <limits>

const int INF = std::numeric_limits<int>::max(); // 代表无穷大

struct Edge
{
    int u, v, weight; // 边的起点、终点和权重
};

//{权重，顶点}
using ipair = std::pair<int, int>; // 用于存储权重和顶点的对

// Dijkstra 算法实现
// V: 顶点数量
// startNode: 源点
// Edge: 图的边列表{u, v, weight}
void dijkstra(int V, int startNode, std::vector<Edge> edges)
{
    // 距离数组，初始化为无穷大
    std::vector<int> dist(V, INF);
    dist[startNode] = 0;

    // 邻接表表示图
    std::vector<std::vector<ipair>> adj(V);
    for (const auto &edge : edges)
    {
        // 有向图
        adj[edge.u].push_back({edge.weight, edge.v});
        // 如果是无向图，则添加以下行
        // adj[edge.v].push_back({edge.weight, edge.u});
    }

    // 优先队列（最小堆），存储 {距离, 顶点}
    // std::greater 使其成为最小堆
    std::priority_queue<ipair, std::vector<ipair>, std::greater<ipair>> pq;

    pq.push({0, startNode});

    while (!pq.empty())
    {
        // 取出当前已知最短路径的顶点
        int u = pq.top().second;
        int d = pq.top().first;
        pq.pop();

        // 如果这个顶点的最短路径已经被更新过，则跳过
        if (d > dist[u])
        {
            continue;
        }

        // 遍历所有邻接点
        for (auto &edge : adj[u])
        {
            int v = edge.second;
            int weight = edge.first;

            // 松弛操作
            if (dist[u] + weight < dist[v])
            {
                dist[v] = dist[u] + weight;
                pq.push({dist[v], v});
            }
        }
    }

    // 打印从源点到所有顶点的最短距离
    std::cout << "Dijkstra 算法的结果：" << std::endl;
    for (int i = 0; i < V; ++i)
    {
        if (dist[i] == INF)
        {
            std::cout << "顶点 " << startNode << " -> " << i << ": No path" << std::endl;
        }
        else
        {
            std::cout << "顶点 " << startNode << " -> " << i << ": " << dist[i] << std::endl;
        }
    }
}

int main()
{
    int V = 7; // 顶点数
    int startNode = 0;

    std::vector<Edge> edges =
        {
            {0, 1, 8},
            {0, 2, 12},
            {0, 3, 19},
            {0, 4, 21},
            {1, 2, 13},
            {1, 3, 4},
            {1, 4, 5},
            {1, 5, 5},
            {2, 5, 21},
            {3, 4, 19},
            {3, 6, 11},
            {5, 3, 9},
            {5, 6, 3}};

    dijkstra(V, startNode, edges);
    return 0;
}

代码输出：

Dijkstra 算法的结果：
顶点 0 -> 0: 0
顶点 0 -> 1: 8
顶点 0 -> 2: 12
顶点 0 -> 3: 12
顶点 0 -> 4: 13
顶点 0 -> 5: 13
顶点 0 -> 6: 16

动画演示过程如下：

3. Bellman-Ford 算法

Bellman-Ford 算法（贝尔曼-福特算法） 同样用于解决单源最短路径问题，但它比 Dijkstra 更强大，因为它可以处理带负权边的图，并且能够检测负权环。

Bellman-Ford 的核心思想是动态规划。它通过对图中所有的边进行 V-1 轮松弛操作来逐步逼近最短路径。

经过第 1 轮松弛，可以找到从源点出发、最多经过 1 条边的最短路径。
经过第 2 轮松弛，可以找到从源点出发、最多经过 2 条边的最短路径。
经过 V-1 轮松弛，可以找到从源点出发、最多经过 V-1 条边的最短路径。因为在一个不包含负权环的图中，任意两点间的最短路径最多包含 V-1 条边。

算法步骤如下：

初始化：
- 创建一个距离数组 dist，将源点 startNode 的距离 dist[startNode] 初始化为 0，其他所有顶点的 dist 初始化为无穷大 (INF)。
迭代松弛：
- 重复 V-1 次以下操作：
- 遍历图中的每一条边 (u, v)，其权重为 w。
- 松弛操作：如果 dist[u] + w < dist[v]，则更新 dist[v] 为 dist[u] + w。
检测负权环：
- 完成 V-1 轮松弛后，再进行第 V 轮松弛：
- 遍历图中的每一条边 (u, v)。
- 如果仍然可以进行松弛操作（即 dist[u] + w < dist[v]），则说明图中存在一个从源点可达的负权环。因为在没有负权环的情况下，V-1 轮后所有最短路径都已确定，不应再有更新。

C++ 代码实现如下：

#include <iostream>
#include <vector>
#include <queue>
#include <limits>

const int INF = std::numeric_limits<int>::max(); // 代表无穷大

struct Edge
{
    int u, v, w; // 边的起点、终点和权重
};

// Bellman-Ford 算法实现
// V: 顶点数量, E: 边的数量
// edges: 边的列表
// startNode: 源点
void bellmanFord(int V, int startNode, const std::vector<Edge> &edges)
{
    std::vector<int> dist(V, INF);
    dist[startNode] = 0;

    // 1. 进行 V-1 轮松弛操作
    for (int i = 0; i < V - 1; ++i)
    {
        for (const auto &edge : edges)
        {
            if (dist[edge.u] != INF && dist[edge.u] + edge.w < dist[edge.v])
            {
                dist[edge.v] = dist[edge.u] + edge.w;
            }
        }
    }

    // 2. 检测负权环
    bool hasNegativeCycle = false;
    for (const auto &edge : edges)
    {
        if (dist[edge.u] != INF && dist[edge.u] + edge.w < dist[edge.v])
        {
            hasNegativeCycle = true;
            break;
        }
    }

    // 3. 打印结果
    std::cout << "Bellman-Ford 算法的结果：" << std::endl;
    if (hasNegativeCycle)
    {
        std::cout << "图中包含负权重环！" << std::endl;
    }
    else
    {
        for (int i = 0; i < V; ++i)
        {
            if (dist[i] == INF)
            {
                std::cout << "顶点 " << startNode << " -> " << i << ": No path" << std::endl;
            }
            else
            {
                std::cout << "顶点 " << startNode << " -> " << i << ": " << dist[i] << std::endl;
            }
        }
    }
}
int main()
{
    int V = 6; // 顶点数
    int startNode = 0;

    std::vector<Edge> edges =
        {
            {0, 1, -5},
            {0, 2, 2},
            {1, 2, 3},
            {1, 3, 4},
            {1, 4, 5},
            {2, 5, 1},
            {3, 4, 2},
            {3, 5, 2},
            {4, 5, 3},
            {5, 1, -2}};

    bellmanFord(V, startNode, edges);
    return 0;
}

代码输出：

Bellman-Ford 算法的结果：
顶点 0 -> 0: 0
顶点 0 -> 1: -5
顶点 0 -> 2: -2
顶点 0 -> 3: -1
顶点 0 -> 4: 0
顶点 0 -> 5: -1

4. SPFA 算法

SPFA 算法是 Bellman-Ford 算法的一种队列优化版本，同样用于解决单源最短路径问题，并且能够处理负权边和检测负权环。

Bellman-Ford 算法的瓶颈在于它每一轮迭代都会盲目地尝试松弛所有的边，而实际上，只有那些在上一轮中距离被缩短了的顶点，才有可能去更新它们的邻接点。而SPFA 算法正是基于这个观察进行优化。它维护一个队列，队列中存放的是“刚刚被成功松弛过”的顶点。算法每次从队列中取出一个顶点 u，然后用 u 去松弛它的所有邻接点 v。如果 v 被成功松弛，并且 v 当前不在队列中，就将 v 加入队列。这个过程不断重复，直到队列为空。

由于只有“可能引发更新”的顶点才会入队并被用于松弛操作，SPFA 在大多数情况下（尤其是稀疏图）避免了 Bellman-Ford 中的大量冗余计算，因此平均效率要高得多。

算法步骤如下：

初始化：
- 创建一个距离数组 dist，将源点 startNode 的距离 dist[startNode] 初始化为 0，其他所有顶点的 dist 初始化为无穷大 (INF)。
- 创建一个队列 q，并将源点 startNode 入队。
- 创建一个布尔数组 in_queue，用于标记顶点是否在队列中。将 in_queue[startNode] 设为 true。
- 创建一个计数器数组 count，count[i] 记录顶点 i 入队的次数，用于检测负权环。
主循环：当队列 q 不为空时：
- 从队首取出一个顶点 u，并将其出队。将 in_queue[u] 设为 false。
- 遍历 u 的所有邻接点 v（权重为 w）：
  - 松弛操作：如果 dist[u] + w < dist[v]，则更新 dist[v] 为 dist[u] + w。
  - 如果 v 被成功松弛，且 v 当前不在队列中：
  - 将 v 入队，并设置 in_queue[v] 为 true。
  - 增加 v 的入队计数 count[v]。
  - 检测负权环：如果 count[v] 大于等于图的顶点总数 V，则说明从源点到 v 的路径上存在一个负权环。算法可以立即终止并报告。
结束：如果队列为空且没有检测到负权环，dist 数组就包含了源点到所有其他顶点的最短路径。

C++ 代码如下：

#include <iostream>
#include <vector>
#include <queue>
#include <limits>

const int INF = std::numeric_limits<int>::max(); // 代表无穷大

struct Edge
{
    int to;     // 边的终点
    int weight; // 边的权重
};

// SPFA 算法实现
// V: 顶点数量
// adj: 邻接表表示的图
// startNode: 源点
void spfa(int V, int startNode, const std::vector<std::vector<Edge>> &adj)
{
    std::vector<int> dist(V, INF);
    std::vector<int> inQueueCount(V, 0); // 记录每个顶点入队的次数
    std::vector<bool> inQueue(V, false); // 标记顶点是否在队列中
    std::queue<int> q;

    dist[startNode] = 0;
    q.push(startNode);
    inQueue[startNode] = true;
    inQueueCount[startNode]++;

    bool hasNegativeCycle = false;

    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        inQueue[u] = false;

        for (const auto &edge : adj[u])
        {
            int v = edge.to;
            int w = edge.weight;

            if (dist[u] != INF && dist[u] + w < dist[v])
            {
                dist[v] = dist[u] + w;
                if (!inQueue[v])
                {
                    q.push(v);
                    inQueue[v] = true;
                    inQueueCount[v]++;
                    // 如果一个顶点入队次数超过 V，则存在负权环
                    if (inQueueCount[v] > V)
                    {
                        hasNegativeCycle = true;
                        goto end_loop; // 跳出外层循环
                    }
                }
            }
        }
    }

end_loop:;

    // 3. 打印结果
    std::cout << "SPFA 算法的结果：" << std::endl;
    if (hasNegativeCycle)
    {
        std::cout << "图中包含负权重环！" << std::endl;
    }
    else
    {
        for (int i = 0; i < V; ++i)
        {
            if (dist[i] == INF)
            {
                std::cout << "顶点 " << startNode << " -> " << i << ": No path" << std::endl;
            }
            else
            {
                std::cout << "顶点 " << startNode << " -> " << i << ": " << dist[i] << std::endl;
            }
        }
    }
}

int main()
{
    int V = 6; // 顶点数
    int startNode = 0;

    // 为了使用 SPFA，最好将边列表转换为邻接表
    std::vector<std::vector<Edge>> adj(V);
    std::vector<std::pair<int, std::pair<int, int>>> edges =
        {
            {0, {1, -5}},
            {0, {2, 2}},
            {1, {2, 3}},
            {1, {3, 4}},
            {1, {4, 5}},
            {2, {5, 1}},
            {3, {4, 2}},
            {3, {5, 2}},
            {4, {5, 3}},
            {5, {1, -2}}};

    for (const auto &edge_info : edges)
    {
        int u = edge_info.first;
        int v = edge_info.second.first;
        int w = edge_info.second.second;
        adj[u].push_back({v, w});
    }

    spfa(V, startNode, adj);
    return 0;
}

输出结果为：

SPFA 算法的结果：
顶点 0 -> 0: 0
顶点 0 -> 1: -5
顶点 0 -> 2: -2
顶点 0 -> 3: -1
顶点 0 -> 4: 0
顶点 0 -> 5: -1

并查集

Tue, 08 Jul 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

1. 简介

并查集（Disjoint Set Union, DSU） 是一种用来高效处理一些不相交集合的合并及查找问题的数据结构，它可以高效地完成两件事：

查找（Find）：确定一个元素属于哪个集合
合并（Union）：将两个不同集合合并成一个大的集合

因为这两个核心操作，它也被称为“Union-Find”数据结构。

2. 实现

并查集的实现思路可以分为两种：Quick Find 和 Quick Union。这两种方式在如何组织数据以及执行 Find 和 Union 操作上有所不同。

2.1 Quick Find

Quick Find 的核心思想是用一个数组 id[] 来存储每个元素所属集合的标识符。id[i] 的值就是元素 i 所在集合的 "名字"。

初始化：id[i] = i。每个元素都属于一个以自己为标识的独立集合。
Find (查找)：Find(p, q) 操作就是检查 id[p] 是否等于 id[q]。这是一个 O(1) 的操作，非常快，这也是它“Quick Find”名字的由来。
Union (合并)：Union(p, q) 操作稍微复杂。要将 p 和 q 所在的集合合并，需要遍历整个 id 数组。将所有与 id[p] 相同的元素的集合标识符，全部修改为 id[q] 的值。

C++代码实现如下：

#include <vector>

class QuickFind 
{
public:
    std::vector<int> id;

    // 初始化并查集
    QuickFind(int size) 
    {
        id.resize(size);
        for (int i = 0; i < size; ++i) 
        {
            id[i] = i;
        }
    }

    // 查找p和q是否在同一个集合
    bool Find(int p, int q) 
    {
        return id[p] == id[q];
    }

    // 合并p和q所在的集合
    void Union(int p, int q) 
    {
        int p_id = id[p];
        int q_id = id[q];

        if (p_id == q_id) 
        {
            return;
        }

        // 遍历整个数组，将所有属于p集合的元素，归入q集合
        for (int i = 0; i < id.size(); ++i) 
        {
            if (id[i] == p_id) 
            {
                id[i] = q_id;
            }
        }
    }
};

优点：Find 操作极快，时间复杂度为 O(1)。
缺点：Union 操作非常慢。每次合并都需要遍历整个数组，时间复杂度为 O(N)。如果进行 N 次合并操作，总时间复杂度会达到 O($N^2$)，在处理大规模数据时效率很低。

2.2 Quick Union

Quick Union 是主流的并查集实现方式，它将数据组织成一个森林（多棵树），每个集合是一棵树。数组 parent[i] 存储的是元素 i 的父节点。

初始化：parent[i] = i。每个元素都是一棵单节点树的根。
Find (查找)：find(p) 操作是从节点 p 开始，沿着父节点指针一路向上，直到找到根节点（即 parent[i] == i 的节点）。这个根节点就是集合的代表。
Union (合并)：union(p, q) 操作是先分别找到 p 和 q 的根节点 rootP 和 rootQ。如果它们不相同，只需将一棵树的根节点设置为另一棵树的子节点即可。例如，parent[rootP] = rootQ。

C++ 代码实现如下：

#include <vector>

class QuickUnion 
{
public:
    std::vector<int> parent;

    // 初始化并查集
    QuickUnion(int size) 
    {
        parent.resize(size);
        for (int i = 0; i < size; ++i) 
        {
            parent[i] = i;
        }
    }

    // 查找p的根节点
    int Find(int p) 
    {
        while (p != parent[p]) 
        {
            p = parent[p];
        }
        return p;
    }

    // 合并p和q所在的集合
    void Union(int p, int q) 
    {
        int rootP = Find(p);
        int rootQ = Find(q);

        if (rootP != rootQ) 
        {
            parent[rootP] = rootQ;
        }
    }
};

优点：Union 操作非常快。只需要找到两个根节点并修改一次指针，时间复杂度主要取决于 Find 操作。
缺点：Find 操作可能很慢。在最坏的情况下，树可能退化成一条长链，导致 Find 的时间复杂度达到 O(N)。

可以看到虽然 Quick Union 解决了 Union 慢的问题，但引入了 Find 可能慢的新问题。为了解决 Find 的瓶颈，通常会引入路径压缩 (Path Compression) 和 按秩/大小合并 (Union by Rank/Size) 这两大优化。

2.3 路径压缩

路径压缩是在 Find 操作中进行优化的，核心思想是当我们要查找一个节点 x 的根节点时，我们会从 x 出发，沿着父节点指针一路向上，直到找到根。在这个过程中，我们经过了一条路径。路径压缩的精髓在于：在找到根之后，将这条路径上的所有节点都直接连接到根节点上。下次再查找这条路径上的任何一个节点时，只需一步就能直接访问到根节点。这极大地降低了树的高度。

这通常是用递归来实现的，C++ 代码如下：

// 查找p的根节点，并进行路径压缩
int Find(int p) 
{
    if (parent[p] != p) 
    {
        // 递归向上查找根节点，
        // 并且在回溯时，将p的父节点直接设置为最终的根节点
        parent[p] = Find(parent[p]);
    }
    return parent[p];
}

2.4 按秩合并/按大小合并

按秩合并是在 Union 操作中进行的，核心思想是为每个集合（即每棵树的根节点）维护一个叫做“秩” (rank) 的属性。rank 可以理解为树的高度的上界。在合并两个集合时，总是将秩较小的树的根节点，连接到秩较大的树的根节点上。

按大小合并与按秩合并非常相似，但维护的不是 rank，而是每个集合中元素的数量 (size)。在合并时，总是将节点数较少的树，合并到节点数较多的树上。

最终使用两种优化方式的并查集的 C++ 实现如下：

#include <vector>

class UnionFind 
{
public:
    std::vector<int> parent;
    std::vector<int> size;

    // 初始化并查集
    UnionFind(int n) 
    {
        parent.resize(n);
        size.resize(n, 1);
        for (int i = 0; i < n; ++i) 
        {
            parent[i] = i;
        }
    }

    // 查找元素i的根节点，并进行路径压缩
    int find(int i) {
        if (parent[i] == i) 
        {
            return i;
        }
        // 递归查找根，并将路径上所有节点直接指向根
        parent[i] = find(parent[i]);
        return parent[i];
    }

    // 按大小合并元素i和j所在的集合
    void unionElements(int i, int j) 
    {
        int rootI = find(i);
        int rootJ = find(j);

        if (rootI != rootJ) 
        {
            // 按大小合并：将小树合并到大树上
            if (size[rootI] < size[rootJ]) 
            {
                parent[rootI] = rootJ;
                size[rootJ] += size[rootI];
            } 
            else 
            {
                parent[rootJ] = rootI;
                size[rootI] += size[rootJ];
            }
        }
    }
};

最小生成树

Tue, 08 Jul 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

1. 简介

最小生成树（Minimum Spanning Tree，简称 MST） 是图论中的一个重要概念，主要应用于带权无向连通图中。给定一个带权无向连通图，它的最小生成树包含图中所有的顶点，但只包含一部分边，并且满足以下三个条件：

是一棵树：这意味着图中没有任何环路
是一棵生成树：这意味着包含图中的所有顶点
权重之和最小：在所有可能的生成树中，它的所有边的权重之和是最小的

例如对于下面的带权无向连通图：

它的最小生成树为：

最小生成树有两个非常重要的性质，是构建算法的基础：

切割性质（Cut Property）：将图中的所有顶点分成两个不相交的集合。在所有横跨这两个集合的边中（即一个端点在一个集合，另一个端点在另一个集合），权重最小的那条边，必定属于图的某一个最小生成树。例如按蓝色这条线切割，权重为5这条边肯定属于最小生成树：
环路性质（Cycle Property）：对于图中的任意一个环路。这个环路中权重最大的那条边，一定不属于任何一个最小生成树。例如对于红色这个环路，权重为4这条边肯定不属于最小生成树：

2. 应用场景

最小生成树在日常有着广泛的应用，主要用于解决如何以最低成本连接所有点的问题：

网络设计：铺设通信电缆、输水管道、电网、公路网等，目标是覆盖所有地点且总长度或成本最低。
聚类分析：在数据科学中，可以用来帮助识别数据点簇。
电路设计：在设计电路板时，确保所有引脚都连接起来，并且使用的导线总长度最短。
近似算法：在解决一些更复杂的问题（如旅行商问题）时，最小生成树可以作为一个很好的近似解或解决过程中的一个步骤。

3. 经典算法

寻找最小生成树主要有三种经典算法，分别是：Prim 算法、Kruskal 算法和 Boruvka 算法。其中 Boruvka 的并行友好特性使其在高性能计算和处理大规模图数据时具有不可替代的优势。我们这里主要讨论的是Prim 算法和Kruskal 算法，它们两个都是属于贪心算法，即在每一步都做出当前的最优选择，最终得到全局最优解。

3.1 Kruskal 算法

Kruskal 算法（克鲁斯卡尔算法） 的思路是：从权重最小的边开始，依次考察所有边。如果当前这条边连接的两个顶点还没有被连通（即加入这条边不会形成环路），就将它加入到最小生成树中。重复这个过程，直到加入了 n-1 条边为止（对于一个有 n 个顶点的图，其生成树恰好有 n-1 条边）。具体步骤：

将图中所有的边按照权重从小到大进行排序，然后创建一个只包含所有顶点但没有边的图，每个顶点初始时都各自属于一个独立的集合。
从排序好的边中，依次取出权重最小的边。
判断这条边的两个顶点是否属于同一个集合（如果属于，说明它们已经连通，加入这条边会形成环路）。属于则跳过，不属于则加入到最小生成树中
重复步骤4，直到最小生成树中有 n-1 条边。

Kruskal 算法的 C++ 实现如下：

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

// 定义边的结构体
struct Edge
{
    int src, dest, weight;
};

// 并查集结构体
struct UnionFind
{
    std::vector<int> parent;
    UnionFind(int n)
    {
        parent.resize(n);
        // 初始化，每个元素的父节点都是它自己
        for (int i = 0; i < n; ++i)
        {
            parent[i] = i;
        }
    }

    // 查找元素i所在集合的根节点（带路径压缩）
    int Find(int i)
    {
        if (parent[i] == i)
            return i;
        return parent[i] = Find(parent[i]);
    }

    // 合并i和j所在的集合
    void Union(int i, int j)
    {
        int root_i = Find(i);
        int root_j = Find(j);
        if (root_i != root_j)
        {
            parent[root_i] = root_j;
        }
    }
};

// 比较函数，用于排序
bool compareEdges(const Edge &a, const Edge &b)
{
    return a.weight < b.weight;
}

// Kruskal算法主函数
void kruskalMST(int V, std::vector<Edge> &edges)
{
    // 1. 按权重对所有边进行升序排序
    std::sort(edges.begin(), edges.end(), compareEdges);

    UnionFind union_find(V);
    std::vector<Edge> resultMST;
    int totalWeight = 0;

    // 2. 遍历排序后的边
    for (const auto &edge : edges)
    {
        int u = edge.src;
        int v = edge.dest;

        // 3. 如果加入这条边不会形成环路
        if (union_find.Find(u) != union_find.Find(v))
        {
            // 将这条边加入结果集
            resultMST.push_back(edge);
            totalWeight += edge.weight;

            // 合并两个顶点的集合
            union_find.Union(u, v);
        }

        // 当MST中的边数达到 V-1 时，可以提前结束
        if (resultMST.size() == V - 1)
            break;
    }

    // 打印结果
    std::cout << "Kruskal 算法找到的最小生成树如下:" << std::endl;
    for (const auto &edge : resultMST)
    {
        std::cout << "边 " << edge.src << " - " << edge.dest << "   权重: " << edge.weight << std::endl;
    }
    std::cout << "最小生成树的总权重: " << totalWeight << std::endl;
}

int main()
{
    int V = 5; // 顶点数
    std::vector<Edge> edges =
        {
            {0, 1, 2},
            {0, 3, 6},
            {1, 2, 3},
            {1, 3, 8},
            {1, 4, 5},
            {2, 4, 7},
            {3, 4, 9}
        };

    kruskalMST(V, edges);

    return 0;
}

算法输出：

Kruskal 算法找到的最小生成树如下:
边 0 - 1   权重: 2
边 1 - 2   权重: 3
边 1 - 4   权重: 5
边 0 - 3   权重: 6
最小生成树的总权重: 16

动画演示：

3.2 Prim 算法

Prim 算法（普里姆算法） 的思路是：从任意一个顶点开始，逐步扩大一棵正在生长的树。在每一步，都寻找一条连接树内顶点和树外顶点的、权重最小的边，并将这条边和它所连接的树外顶点加入到树中。重复这个过程，直到所有顶点都被加入。具体步骤：

选择任意一个顶点作为起始点，将其加入到一个集合 U 中（表示已经是最小生成树的一部分）。
寻找所有一个端点在集合 U 中，另一个端点不在 U 中的边。在这些边中，找到权重最小的那一条。
将这条权重最小的边和它连接的那个不在 U 中的顶点加入到最小生成树和集合 U 中。
重复步骤2-3，直到所有顶点都加入了集合 U

Prim 算法的 C++ 实现如下：

#include <iostream>
#include <vector>
#include <queue>
#include <limits>

// 定义一个类型别名，方便使用
// pair<权重, 顶点>
using iPair = std::pair<int, int>;

// Prim算法主函数
void primMST(int V, const std::vector<std::vector<iPair>> &adj)
{
    // 使用优先队列作为最小堆，存储 {权重, 顶点}
    // std::greater 使其成为最小堆
    // 优先队列会使用pair的第一个元素（权重）进行排序，如果第一个元素相同再排序第二个元素（顶点）
    std::priority_queue<iPair, std::vector<iPair>, std::greater<iPair>> pq;

    // 选择顶点0作为起始点
    int src = 0;

    // 存储连接到MST的最小权重，初始化为无穷大
    // 如果为无穷大，表示这个权重对应的边的两个顶点都没有在最小生成树中
    std::vector<int> minWeight(V, std::numeric_limits<int>::max());
    // 存储父节点，用于构建最小生成树（MST），便于打印输出结果
    std::vector<int> parent(V, -1);
    // 标记顶点是否访问过
    std::vector<bool> visited(V, false);

    // 初始化起始点
    pq.push({0, src});
    minWeight[src] = 0;

    int totalWeight = 0;

    while (!pq.empty())
    {
        // 从优先队列中取出权重最小的顶点
        int u = pq.top().second;
        // 取出顶点的权重
        int w = pq.top().first;
        pq.pop();

        // 如果顶点已经处理过，则跳过，防止环路
        if (visited[u])
        {
            continue;
        }

        // 将顶点标记为已访问
        visited[u] = true;
        totalWeight += w;

        // 遍历u的所有邻接点
        for (const auto &edge : adj[u])
        {
            int weight = edge.first;
            int v = edge.second;

            // 如果v没有访问过，并且通过u连接v的权重更小
            if (!visited[v] && minWeight[v] > weight)
            {
                // 更新v的minWeight值和父节点
                minWeight[v] = weight;
                pq.push({weight, v});
                parent[v] = u;
            }
        }
    }

    // 打印结果
    std::cout << "Prim 算法找到的最小生成树如下:" << std::endl;
    for (int i = 1; i < V; ++i)
    {
        // minWeight[i] 就是连接 parent[i] 和 i 的边的权重
        std::cout << "边 " << parent[i] << " - " << i << "   权重: " << minWeight[i] << std::endl;
    }
    std::cout << "最小生成树的总权重: " << totalWeight << std::endl;
}

int main()
{
    int V = 5;
    // 使用邻接表表示图
    std::vector<std::vector<iPair>> adj(V);

    //使用lambda表达式构建邻接表
    auto addEdge = [&](int u, int v, int w)
    {
        adj[u].push_back({w, v});
        adj[v].push_back({w, u});
    };

    addEdge(0, 1, 2);
    addEdge(0, 3, 6);
    addEdge(1, 2, 3);
    addEdge(1, 3, 8);
    addEdge(1, 4, 5);
    addEdge(2, 4, 7);
    addEdge(3, 4, 9);

    primMST(V, adj);

    return 0;
}

动画演示：

堆及其相关应用

Mon, 07 Jul 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

1. 堆简介

堆本质上是一棵树结构，其每个节点的键值都大于等于或者小于等于其父节点的键值。这里主要讨论的是二叉堆。

二叉堆是一种特殊的完全二叉树。完全二叉树是指，除了最后一层外，其他各层的节点数都达到最大，并且最后一层的节点都连续集中在左侧。除了结构上的要求，堆中的节点还需要满足堆序性：

最大堆（Max Heap）：每个节点的值都大于或等于其子节点的值。因此，堆顶（根节点）的元素是整个堆中的最大值。
最小堆（Min Heap）：每个节点的值都小于或等于其子节点的值。因此，堆顶（根节点）的元素是整个堆中的最小值。

最大堆：

最小堆：

2. 堆的存储

尽管堆是树形结构，但它通常用数组来实现高效存储，堆节点在数组中的存储顺序通常是层序遍历的顺序，因此堆中的树节点和它的子节点在数组的索引是有数学关系的。对于数组中索引为 i 的节点：

其父节点的索引为 floor((i-1)/2)
其左子节点的索引为 2*i + 1
其右子节点的索引为 2*i + 2

3. 堆的操作

堆的操作主要有两种：插入和删除。插入和删除后都有可能不再满足堆的定义，需要重新进行调整，使其重新满足堆的特性，这个过程叫做堆化。堆化分为两种：上浮和下沉。

3.1 插入上浮

上浮主要用于插入操作中，执行插入时通常会把一个新元素添加到堆的末尾，这是它可能会比它的父节点更大（在最大堆中）或更小（在最小堆中），从而违反了堆属性。上浮操作就是将这个新元素与其父节点比较并交换，直到它找到合适的位置，恢复堆属性。以最大堆为例，插入的过程如下：

将新元素放在数组的末尾
比较新元素和它的父节点
如果新元素比父节点大，则交换它们
重复步骤 2 和 3，直到新元素不再比它的父节点大，或者它已经到达了堆顶

上浮操作的 C++ 实现如下：

void siftUp(vector<int>& heap, int idx)
{
    while (idx > 0)
    {
        int parent = (idx - 1) / 2;
        if (heap[idx] <= heap[parent]) break;  // 最大堆：子 ≤ 父，则停止
        swap(heap[idx], heap[parent]);
        idx = parent;
    }
}

插入操作的 C++ 实现如下：

void insert(vector<int>& heap, int value)
{
    heap.push_back(value);
    siftUp(heap, heap.size() - 1);
}

插入操作的动画：

3.2 删除下沉

下沉主要用于删除操作中，执行删除操作将某个节点元素移除后，通常会用堆的最后一个元素来填补空缺。填补元素后很可能违反堆属性。下沉操作就是将这个元素与其子节点中较大者（在最大堆中）或较小者（在最小堆中）比较并交换，直到它找到合适的位置。以最大堆为例，删除的过程如下：

将堆的最后一个元素移动到删除位置
比较当前节点和它的左右子节点，找出最大的那个子节点
如果当前节点比它最大的子节点要小，则交换它们
重复步骤 2 和 3，顺着交换路径继续向下比较和交换，直到当前节点不再比它的任何子节点小，或者它已经成为一个叶子节点。

下沉操作的 C++ 实现如下：

void siftDown(vector<int>& heap, int idx)
{
    int n = heap.size();
    while (true)
    {
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        int largest = idx;
        if (left < n && heap[left] > heap[largest]) largest = left;
        if (right < n && heap[right] > heap[largest]) largest = right;
        if (largest == idx) break;
        swap(heap[idx], heap[largest]);
        idx = largest;
    }
}

弹出（删除）堆顶点的 C++ 实现如下：

int popHeap(vector<int>& heap)
{
    if (heap.empty()) throw out_of_range("Heap is empty");
    int top = heap[0];
    heap[0] = heap.back();
    heap.pop_back();
    if (!heap.empty()) siftDown(heap, 0);
    return top;
}

弹出堆顶元素的动画：

4. 堆的构建

从一个无序的元素集合构建一个完整堆的过程，通常被称为建堆，构建堆通常有两种方法：

逐个插入法
原地建堆法

4.1 逐个插入法

逐个插入法的思路非常直观，首先初始化一个空的堆，然后遍历数组，将每个元素依次插入进堆里面，遍历完数组后即建堆完成。每次插入操作的时间复杂度是 O(log k)，其中 k 是堆中当前的元素数量。当插入 N 个元素时，总的时间复杂度为所有插入操作的总和，即 O(log 1) + O(log 2) + ... + O(log N)，这最终可以近似为 O(N log N)。

C++ 实现如下：

void buildHeap(vector<int>& heap)
{
    vector<int> new_heap(heap.size());
    for(int val:heap)
    {
        insert(new_heap, val);
    }
    heap = new_heap;
}

构建的动画如下：

4.2 原地建堆法

原地建堆法则是构建堆的标准算法，也叫 Floyd 算法，它比逐个插入法更加高效，它是一个自底向上的方法。构建的核心思想是将每一个叶子节点视为一个堆，因此只需要处理所有的非叶子节点，确保它们满足堆的属性即可。我们需要从最后一个非叶子节点开始，向前遍历直到根节点，对每个节点执行下沉操作。

算法的具体过程如下：

将所有元素直接放入一个数组中，此时它只是一个完全二叉树，不一定是堆。
找到最后一个非叶子节点的索引。对于一个大小为 N 的数组，该索引是 floor(N / 2) - 1。
从这个索引开始，向前遍历到根节点（索引 0）。
对遍历到的每个节点，执行下沉（siftDown）操作。

时间复杂度分析：虽然这个算法看起来像是执行了 N/2 次 siftDown 操作（每次 O(log N)），因此总的时间复杂度为 O(N log N)，但是这个直觉是错误的。更精确的数学分析表明，大部分节点的下沉路径都很短。越靠近底部的节点越多，但它们下沉的距离也越短。总的操作数可以被证明是一个与 N 呈线性关系的级数，因此时间复杂度为 O(N)。

C++ 实现如下：

void buildHeap(vector<int>& heap)
{
    int n = heap.size();
    // 最后一个非叶节点索引 = (n/2) - 1
    for (int i = n / 2 - 1; i >= 0; --i)
    {
        siftDown(heap, i);
    }
}

构建动画如下：

int main() { std::vector data = {3, 19, 1, 14, 8, 7};

// 使用 std::make_heap 将 vector 原地转换成一个最大堆
// 它接受一对迭代器，定义了要操作的范围
std::make_heap(data.begin(), data.end());

std::cout << "Heap built with std::make_heap: ";
for (int val : data) 
{
    std::cout << val << " ";
}
std::cout << std::endl;
// 输出可能为：19 14 7 3 8 1 (或其他合法的最大堆排列)

return 0;

}

</Aside>

## 5. 堆排序

**堆排序**是借助堆结构所实现的排序算法，通常使用大顶堆来实现升序排序，小顶堆来实现降序排序。核心思想是将数组转化为大顶堆（小顶堆）后，重复从大顶堆（小顶堆）中取出数值最大（数值最小）的节点，并让剩余的堆结构继续维持大顶堆（小顶堆）的性质。以大顶堆为例，堆排序算法的步骤如下：
- **构建大顶堆**：从最后一个非叶子节点开始，向前逐个对节点进行“下沉”调整，确保以该节点为根的子树满足最大堆的性质。经过一系列调整后，整个数组就变成了一个最大堆。
- **执行排序**：循环地将堆顶元素（当前最大值）与堆末尾的元素交换，然后缩小堆的范围并重新调整堆，使其继续满足最大堆的性质。
- 当所有元素都从堆中移除后，数组就变成了一个有序的升序序列。

**时间复杂度**：堆排序的时间复杂度为 O(nlogn)。其中，建堆的过程需要 O(n) 的时间，而之后每次调整堆需要 O(logn) 的时间，共进行 n-1 次。

**空间复杂度**：堆排序是一种原地排序算法，它只需要一个常数级别的额外空间来存储临时变量，因此空间复杂度为 O(1)。

C++ 实现如下：
```cpp
class maxHeap
{
private:
    vector<int> heap;
    void siftdown(int idx,int n)
    {
        while(true)
        {
            int left=2*idx+1;
            int right=2*idx+2;
            int largest=idx;
            if(left<n && heap[left]>heap[largest]) largest=left;
            if(right<n && heap[right]>heap[largest]) largest=right;
            if(largest==idx) break;
            swap(heap[idx],heap[largest]);
            idx=largest;
        }
    }
public:
    void buildMaxHeap(const vector<int>& arr)
    {
        heap=arr;
        int n=heap.size();
        for(int i=(n-2)/2;i>=0;i--)
        {
            siftdown(i,n);
        }
    }
    //堆排序
    vector<int> maxHeapSort(const vector<int>& nums)
    {
        //建堆
        buildMaxHeap(nums);
        int n=heap.size();
        //从最后一个元素开始
        for(int i=n-1;i>0;i--)
        {
            //将堆顶元素放在尾部
            swap(heap[0],heap[i]);
            //缩小堆结构的范围并进行下沉
            siftdown(0,i);
        }
        return heap;
    }
};

class Solution
{
public:
    vector<int> sort(vector<int> nums)
    {
        return maxHeap().maxHeapSort(nums);
    }
};

6. 优先队列

6.1 简介

优先队列是一种特殊的队列，优先队列的元素都会被赋予一个优先级，元素的出队顺序由优先级决定：高优先级的元素先于低优先级的元素出队。如果多个元素具有相同的优先级，则它们的相对顺序没有明确规定。

一个最小优先队列可以很容易地通过将元素的优先级取反来当做最大优先队列使用，反之亦然。

6.2 应用场景

优先队列具有广泛的应用场景，包括：

操作系统任务调度: 操作系统需要管理多个同时运行的进程。优先队列被用来调度 CPU 时间，高优先级的进程（如系统进程）会比低优先级的用户进程先获得执行权。
图算法:
- Dijkstra 最短路径算法: 在寻找图中从一个顶点到所有其他顶点的最短路径时，Dijkstra 算法使用一个最小优先队列来存储待访问的顶点。队列根据已知的从源点到该顶点的距离进行排序，每次从未访问的顶点中选择距离最短的一个进行处理。
- Prim 最小生成树算法: Prim 算法使用最小优先队列来选择连接到当前生成树的、权重最小的边，从而逐步构建最小生成树。
事件驱动模拟 (Event-Driven Simulation): 在模拟系统中，事件被存储在一个以时间为优先级的最小优先队列中。模拟器总是从队列中取出时间最早的事件进行处理，处理该事件可能会触发新的未来事件加入队列。
数据压缩 (Huffman Coding): 在构建霍夫曼树时，使用一个最小优先队列来存储字符及其频率。算法重复地从队列中取出两个频率最低的节点，合并它们，然后将新生成的父节点放回队列，直到队列中只剩一个节点（即霍夫曼树的根）。
A* 搜索算法: 这是广泛用于寻路和图遍历的算法。它使用一个优先队列来决定下一步要探索的节点，其优先级由“已付出的代价”（g-score）和“到目标的预估代价”（h-score）共同决定。

6.3 实现

优先队列的实现方法有很多种：基于数组或链表的实现方式如下： - 无序数组或链表：插入操作非常简单，只需将新元素添加到数组末尾或链表头部即可，时间复杂度为 O(1)。但要查找并删除最高优先级的元素，则需要遍历整个数据结构，找到目标元素，这需要 O(n) 的时间。 - 有序数组或链表：如果我们维持一个按优先级排序的数组或链表，那么查看和删除最高优先级的元素（位于数组或链表的一端）将非常快，仅需 O(1)。然而，为了在插入新元素时保持有序性，可能需要移动大量元素，导致插入操作的时间复杂度为 O(n)。

更加常用的且高效是基于二叉堆的实现方式：

插入: 将新元素添加到堆的末尾，然后通过与其父节点比较和交换，一路“上浮”到正确的位置以维持堆属性。这个过程最多移动树的高度，即 O(logn)。
删除: 将根节点（最高优先级元素）与最后一个元素交换，然后移除根节点。接着，新的根节点通过与子节点比较和交换，一路“下沉”到正确的位置以恢复堆属性。这个过程的时间复杂度也是 O(logn)。

6.4 C++ 中的优先队列

在 C++ 中，<priority_queue> 是标准模板库（STL）的一个容器适配器，，用于实现优先队列。默认情况下，队列中最大的元素拥有最高的优先级。

std::priority_queue 是一个模板类，其声明格式如下：

template <
    class T, // 元素类型
    class Container = std::vector<T>, // 底层容器类型，必须支持随机访问迭代器
    class Compare = std::less<T> // 比较函数对象，决定优先级
> class priority_queue;

常用操作：

empty(): 检查队列是否为空。
size(): 返回队列中的元素数量。
top(): 返回队列顶部的元素（不删除它）。
push(): 向队列添加一个元素。
pop(): 移除队列顶部的元素。

C++ 的 priority_queue 默认使用 std::less<T> 比较器，队列中最大的元素具有最高优先级，如果要最小的元素具有最低优先级，可以传入std::greater<T>比较器。例如：

std::priority_queue<int, std::vector<int>, std::greater<int>> min_heap;

如果是在优先队列中存储自定义的结构体或类时，则需要告诉 std::priority_queue 如何比较它们。有以下几种常用方法：

重载 < 运算符。这种方法比较直接，例如：

struct Task 
{
    int priority;
    std::string name;

    // 重载 < 运算符，priority 值越大，优先级越高
    bool operator<(const Task& other) const {
        return this->priority < other.priority;
    }
};

提供自定义比较函数对象。这种方法更加灵活，可以不修改类本身，例如：

struct Task 
{
    int priority;
    std::string name;
};

// 自定义比较函数对象
struct CompareTask 
{
    // 返回 true 表示 a 的优先级比 b 低
    bool operator()(const Task& a, const Task& b) 
    {
        return a.priority < b.priority; // 最大堆
        // return a.priority > b.priority; // 若要最小堆，则反向比较
    }
};

使用 Lambda 表达式。对于局部的、一次性的比较逻辑，使用 Lambda 表达式非常方便。例如：

struct Point 
{
    int x, y;
    int dist_from_origin() const { return x*x + y*y; }
};

auto compare_points = [](const Point& a, const Point& b) {
    // 距离原点越近，优先级越高 (最小堆)
    return a.dist_from_origin() > b.dist_from_origin();
};

拓扑排序

Sun, 06 Jul 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

1. 拓扑排序简介

拓扑排序是对 有向无环图 (Directed Acyclic Graph, DAG) 的顶点进行的一种线性排序。简单来说，就是将一个 DAG 中所有的顶点排成一个线性序列，使得图中任意一对顶点 u 和 v，若存在一条从 u 指向 v 的边 (u -> v)，那么在这个序列中 u 必须出现在 v 的前面。

拓扑排序主要用于解决依赖关系和执行顺序的问题，主要的应用场景如下：

任务调度或工作流：在一个复杂的项目中，很多任务之间有依赖关系。例如，编译代码时的文件依赖关系 (Makefile)。拓扑排序可以确定任务的执行顺序，确保依赖的任务先完成。
课程的先修关系。例如必须先修完《程序设计》才能修读《数据结构》，拓扑排序可以确定一个满足所有先修课要求的学习计划。
软件包的依赖管理。在安装或卸载软件包时，系统需要解决包之间的依赖关系，例如 Linux 的 apt-get 命令在安装一个包之前，会安装它的所有依赖包，这个依赖解析的过程就用到了拓扑排序。

2. 算法及实现

实现拓扑排序有两种经典的算法：

Kahn 算法 (基于入度的算法)
基于深度优先搜索 (DFS) 的算法

以下面的这个有向无环图为例：

2.1 Kahn 算法

Kahn 算法的思路非常直观，就像模拟 "完成任务" 的过程。一个任务只有在它所有的前置任务都完成后，才能开始执行。算法步骤如下：

计算所有顶点的入度。
- 入度是指有多少条边指向该顶点。
初始化一个队列，并将所有入度为 0 的顶点入队。
- 入度为 0 的顶点意味着它没有任何前置依赖，可以作为起点。
循环执行以下操作，直到队列为空：
- 从队列中取出一个顶点 u，并将其加入到最终的拓扑排序结果序列中。
- 遍历 u 的所有邻接顶点 v（即所有 u 指向的顶点）。
- 对于每一个邻接顶点 v，将其入度减 1 (相当于 u 这个前置任务已经完成了)。
- 如果 v 的入度变为 0，则将 v 入队。
检查结果：
- 如果最终结果序列中的顶点数量与图中顶点总数相等，则说明拓扑排序成功。
- 如果数量不相等，则说明图中存在环，无法进行拓扑排序。

Kahn 算法的 C++ 实现如下：

#include <iostream>
#include <vector>
#include <queue>
#include <string>

// Kahn 算法实现拓扑排序
std::vector<int> topologicalSort_Kahn(int n, const std::vector<std::vector<int>>& adj) 
{
    // 1. 计算所有顶点的入度
    std::vector<int> in_degree(n, 0);
    for (int i = 0; i < n; ++i) 
    {
        for (int neighbor : adj[i]) 
        {
            in_degree[neighbor]++;
        }
    }

    // 2. 将所有入度为 0 的顶点加入队列
    std::queue<int> q;
    for (int i = 0; i < n; ++i) 
    {
        if (in_degree[i] == 0) 
        {
            q.push(i);
        }
    }

    std::vector<int> result; // 存储拓扑排序结果

    // 3. 处理队列中的顶点
    while (!q.empty()) 
    {
        int u = q.front();
        q.pop();
        result.push_back(u);

        // 遍历 u 的所有邻接点，并将其入度减 1
        for (int v : adj[u]) 
        {
            in_degree[v]--;
            // 如果邻接点 v 的入度变为 0，则将其入队
            if (in_degree[v] == 0) 
            {
                q.push(v);
            }
        }
    }

    // 4. 检查结果
    // 如果结果序列中的顶点数不等于总顶点数，说明图中存在环
    if (result.size() != n) 
    {
        return {}; // 返回空向量表示失败
    }

    return result;
}

int main() 
{
    int n = 6; //节点数
    std::vector<std::vector<int>> adj(n);

    // 添加依赖关系 (边)
    adj[0].push_back(1); 
    adj[0].push_back(2); 
    adj[1].push_back(2); 
    adj[2].push_back(5); 
    adj[2].push_back(3);
    adj[3].push_back(4);
    adj[4].push_back(5);

    std::cout << "--- Kahn 算法 ---" << std::endl;
    std::vector<int> sorted_order = topologicalSort_Kahn(n, adj);

    if (sorted_order.empty()) 
    {
        std::cout << "图中存在环，无法进行拓扑排序。" << std::endl;
    } 
    else 
    {
        std::cout << "一个可行的拓扑排序是: " << std::endl;
        for (int i = 0; i < sorted_order.size(); ++i) 
        {
            std::cout << sorted_order[i] << (i == sorted_order.size() - 1 ? "" : " -> ");
        }
        std::cout << std::endl;
    }

    return 0;
}

输出结果为：

--- Kahn 算法 ---
一个可行的拓扑排序是: 
0 -> 1 -> 2 -> 3 -> 4 -> 5

排序的动画如下：

2.2 DFS 算法

基于 DFS 的算法主要利用了 DFS 遍历图的特性。其核心思想是，一个顶点只有在它的所有后续顶点（它能到达的所有顶点）都被访问过之后，才算真正 "完成" 访问。算法步骤如下：

创建一个栈 (Stack) 来存储拓扑排序的结果。
创建一个集合 (Set) 或布尔数组 visited 来记录已访问过的顶点。
遍历图中的每一个顶点 u：
- 如果 u 没有被访问过，则以 u 为起点进行深度优先搜索。
深度优先搜索 (DFS) 函数 dfs(u) 的逻辑：
- 将当前顶点 u 标记为已访问。
- 遍历 u 的所有邻接顶点 v。
- 如果 v 没有被访问过，则递归调用 dfs(v)。
- 当从 u 出发的所有路径都探索完毕后（即所有邻接点都已被访问），将顶点 u 压入栈中。
最终结果：
- 当所有顶点都已被访问后，依次从栈中弹出所有元素，得到的序列就是拓扑排序的结果（逆序）。

如果想要在 DFS 中检测环，需要维护三种状态：

UNVISITED: 未访问
VISITING: 正在访问（当前递归栈中）
VISITED: 已访问完成

如果在 DFS 过程中，遇到了一个状态为 VISITING 的顶点，就说明图中存在环。

DFS 算法的 C++ 实现如下：

#include <iostream>
#include <vector>
#include <stack>
#include <string>
#include <algorithm>

// 顶点的访问状态
enum State { UNVISITED, VISITING, VISITED };

// DFS 辅助函数，发现环返回true，未发现则返回false
bool dfs(int u, const std::vector<std::vector<int>>& adj, std::vector<State>& visited, std::stack<int>& s) 
{
    visited[u] = VISITING; // 标记为正在访问

    for (int v : adj[u]) 
    {
        if (visited[v] == UNVISITED) 
        {
            if (dfs(v, adj, visited, s)) 
            {
                return true; // 如果在子调用中发现了环，立即返回
            }
        } 
        else if (visited[v] == VISITING) 
        {
            // 如果访问到一个正在访问的节点，说明存在环
            return true; 
        }
    }

    visited[u] = VISITED; // 节点 u 的所有邻接点都已访问完毕
    s.push(u); // 将 u 压入栈中
    return false; // 未发现环
}

// 基于 DFS 的拓扑排序实现
std::vector<int> topologicalSort_DFS(int n, const std::vector<std::vector<int>>& adj) 
{
    std::stack<int> s;
    std::vector<State> visited(n, UNVISITED);
    
    // 遍历所有顶点，以处理不连通的图
    for (int i = 0; i < n; ++i) 
    {
        if (visited[i] == UNVISITED) 
        {
            if (dfs(i, adj, visited, s)) 
            {
                // 如果 dfs 函数返回 true，说明检测到了环
                return {}; // 返回空向量表示失败
            }
        }
    }

    // 从栈中弹出元素，构造拓扑序列
    std::vector<int> result;
    while (!s.empty()) 
    {
        result.push_back(s.top());
        s.pop();
    }
    
    return result;
}


int main() {
    int n = 6; // 6 个节点
    std::vector<std::vector<int>> adj(n);

    // 添加依赖关系 (边)
    adj[0].push_back(1); 
    adj[0].push_back(2); 
    adj[1].push_back(2); 
    adj[2].push_back(3); 
    adj[2].push_back(5);
    adj[3].push_back(4);
    adj[4].push_back(5);

    std::cout << "--- DFS 算法 ---" << std::endl;
    std::vector<int> sorted_order = topologicalSort_DFS(n, adj);

    if (sorted_order.empty()) 
    {
        std::cout << "图中存在环，无法进行拓扑排序。" << std::endl;
    } 
    else 
    {
        std::cout << "一个可行的拓扑排序是: " << std::endl;
        for (int i = 0; i < sorted_order.size(); ++i) 
        {
            std::cout << sorted_order[i] << (i == sorted_order.size() - 1 ? "" : " -> ");
        }
        std::cout << std::endl;
    }

    return 0;
}

输出结果为：

--- DFS 算法 ---
一个可行的拓扑排序是: 
0 -> 1 -> 2 -> 3 -> 4 -> 5

排序的动画如下：

3. 复杂度分析

时间复杂度：两种算法都需要遍历所有的顶点和所有的边一次，时间复杂度为 O(V+E)。

空间复杂度：Kahn 算法需要一个队列和数组来存储入度，DFS 算法需要递归栈空间和使用 visited 数组来记录数组的访问状态，空间复杂度都为 O(V)。

C++ 中静态局部变量的使用场景

Sat, 05 Jul 2025 00:00:00 GMT

这里之所以特地写一篇文章记录一下 C++ 中静态局部变量的应用场景，是因为静态局部变量是一种非常特殊的变量：静态局部变量的生命周期是整个程序的运行期间，它在第一次调用所在的函数时初始化，并且到程序结束时才会被销毁。它的作用域仅限于定义它的函数或代码块内部，和普通的局部变量相同。

1. 函数调用计数器

静态局部变量的一个经典应用就是函数调用计数器，由于变量在函数调用结束后不会被销毁，我们可以用它来轻松记录一个函数被调用了多少次。这在调试的时候非常有用。示例：

#include <iostream>

void someFunction() 
{
    static int callCount = 0; // 仅在第一次调用时初始化为 0
    callCount++;
    std::cout << "该函数已被调用 " << callCount << " 次。" << std::endl;
}

int main() 
{
    someFunction(); // 输出: 该函数已被调用 1 次。
    someFunction(); // 输出: 该函数已被调用 2 次。
    someFunction(); // 输出: 该函数已被调用 3 次。
    return 0;
}

在调试的过程中，如果我们不是想知道一个函数被调用了多少次，而是想知道一个函数是否被调用过。例如我们想在一个循环调用的函数中打印一条一次性的进入消息，也可以使用静态局部变量：

void someFunction() 
{
    static bool first_run = true;
    if (first_run) 
    {
        std::cout << "Debug: Performing one-time setup inside someFunction().\n";
        // 在这里可以放置任何你只想执行一次的调试代码或检查
        first_run = false;
    }

    // ... 函数的其余逻辑 ...
}

2. 实现缓存

静态局部变量还可以用来实现缓存，当一个函数的计算成本很高时，并且对于相同的输入总是产生相同的输出时，可以使用静态局部变量来缓存计算结果，避免重复计算。示例：

#include <iostream>
#include <map>
#include <thread>
#include <chrono>

// 模拟一个耗时的计算
int expensiveComputation(int input) 
{
    static std::map<int, int> cache; // 静态缓存

    // 检查结果是否已在缓存中
    if (cache.count(input)) 
    {
        std::cout << "从缓存中命中: " << input << std::endl;
        return cache[input];
    }

    std::cout << "正在计算: " << input << std::endl;
    // 模拟耗时操作
    std::this_thread::sleep_for(std::chrono::seconds(1));
    int result = input * input; // 假设这是复杂计算
    cache[input] = result;
    return result;
}

int main() 
{
    expensiveComputation(5); // 第一次调用，会计算
    expensiveComputation(10); // 第一次调用，会计算
    expensiveComputation(5);  // 第二次调用，直接从缓存返回
    return 0;
}

3. 在递归中保持状态

有时候我们在递归的过程中，需要保持某些状态，除了使用全局变量的方法，还可以使用静态局部变量，例如：

#include <stdio.h>

void recursiveSum(int n) 
{
    static int sum = 0;
    if (n == 0) {
        printf("Total sum: %d\n", sum);
        return;
    }
    sum += n;
    recursiveSum(n - 1);
}

int main() 
{
    recursiveSum(5); // 输出 15
    return 0;
}

4. 生成唯一的 ID

在有一些场景中，我们需要递增生成一些编号作为 ID，这时候就可以使用静态局部变量，例如：

#include <stdio.h>

int generateID() 
{
    static int id = 0;
    return ++id;
}

int main() 
{
    printf("%d\n", generateID());
    printf("%d\n", generateID());
    return 0;
}

这个函数每调用一次，就会返回一个递增的唯一 ID。

5. 有限状态机

在有一些业务场景中，我们需要使用有限状态机来处理一些流程，例如解析器、协议处理等，这就需要一个函数能够记住它上一次执行的状态，这时候可以使用静态局部变量。例如一个处理数据流的函数，需要根据上一次处理的数据块来决定如何处理当前的数据块：

#include <stdio.h>

typedef enum 
{
    STATE_A,
    STATE_B,
    STATE_C
} State;

void process_char(char c) 
{
    static State currentState = STATE_A; // 维护当前状态

    switch (currentState) 
    {
        case STATE_A:
            printf("当前在状态 A, 处理字符: %c\n", c);
            if (c == '1') 
            {
                currentState = STATE_B; // 转换到状态 B
            }
            break;
        case STATE_B:
            printf("当前在状态 B, 处理字符: %c\n", c);
            if (c == '2') 
            {
                currentState = STATE_C; // 转换到状态 C
            }
            break;
        case STATE_C:
            printf("当前在状态 C, 处理字符: %c\n", c);
            if (c == '3') 
            {
                currentState = STATE_A; // 回到状态 A
            }
            break;
    }
}

int main() 
{
    process_char('a');
    process_char('1');
    process_char('b');
    process_char('2');
    process_char('c');
    return 0;
}

6. 实现单例模式

在 C++ 实现单例模式时，为了实现线程安全，需要使用锁，同时还需要进行双重判空，我们可以利用 C++11 可以保证局部静态变量的初始化是线程安全的性质，来实现简洁的线程安全的单例模式：

class Singleton 
{
private:
    Singleton() 
    { 
        std::cout << "Singleton Instance Created\n"; 
    }
    ~Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton& getInstance() 
    {
        static Singleton instance;  // C++11 保证线程安全
        return instance;
    }
};

7. 调试观察点

这是静态变量一个极其强大的调试优势。因为静态局部变量的内存地址在整个程序运行期间是固定的，而普通局部变量存储在栈上，每次函数调用其地址都可能不同。在调试时如果我们怀疑一个变量的值被异常修改，但不知道是哪里的代码干的，调试技巧如下：

在调试器中运行程序，让函数至少执行一次，这样静态变量就被创建了。
在变量窗口中找到该静态变量，右键点击并选择“设置数据断点”或“在此地址设置断点”。
之后，只要这个变量的值发生改变，调试器就会立即中断，并指向导致修改的代码行，我们就可以知道这个变量的值是在哪里更改的了。

C++ 的 static 和 extern 关键字以及相关的概念

Fri, 04 Jul 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

static 和 extern 都是C++中常见的关键字，主要用于控制变量和函数的存储期和链接性，从而决定了标识符在内存中的生命周期以及在不同文件之间的可见性。本文会先介绍作用域和生命周期的概念，然后说明 C++ 中链接属性，最后给出static 和 extern 这两个 C++ 关键字的常见用法。

1. 作用域与生命周期

1.1 作用域

作用域是一个编译时的概念，定义了一个标识符在代码中可以被有效访问的区域，通常会有以下几种作用域：

块作用域：也称局部作用域，任何在花括号 {} 内声明的标识符，其作用域都从声明点开始，到包含它的右花括号 } 结束
函数作用域：标签在整个函数体内都是可见的，无论在何处定义，通常仅适用于 goto 语句中的 label 标签
全局作用域：也称文件作用域，在所有函数、类和代码块之外声明的标识符用于全局作用域，它的作用域从声明点开始，直到当前源文件的末尾。
类作用域：在类（class 或 struct）内部声明的成员拥有类作用域。在类的外部访问它们需要通过类的对象、引用、指针使用成员访问运算符（. 或 ->），对于静态成员要通过类名使用作用域解析运算符 ::
命名空间作用域：在 namespace 中声明的标识符的作用域限定在该命名空间内。访问它们需要使用命名空间名称和作用域解析运算符 ::，或者使用 using 声明。

1.2 生命周期

生命周期是一个运行时的概念，它指的是一个对象从被创建到被销毁的时间段，当一个对象的生命周期结束后，它所占用的内存可能会被回收，访问该对象将导致未定义行为。C++ 中对象的生命周期主要由它的存储期决定的：

自动存储期：局部变量具有自动存储期。当程序的执行流进入其声明所在的块时，对象被创建，当程序的执行流离开该块时，对象被自动销毁。
静态存储期：全局变量、静态局部变量和静态类成员具有静态存储期。静态存储期的变量在 main 函数执行前就被创建和初始化，在 main 函数执行后或者调用 exit 时被销毁。生命周期从程序开始，到程序结束。
动态存储期：使用 new 或者 malloc 在堆或自由存储区上分配的内存中的对象，具有动态存储期。它在 new 时被创建，在 delete 时被销毁，生命周期与作用域无关。
线程存储期：使用 thread_local 修饰的变量，其生命周期和创建的线程一致，线程结束时自动销毁。

2. 链接属性

在 C++ 中，一个程序可以由多个源文件组成的，每个源文件被称为一个翻译单元，编译器会独立地将每个翻译单元编译成一个目标文件，最后链接器会将这些目标文件链接在一起，生成最终的可执行文件。标识符的链接属性会决定该标识符在不同的翻译单元中是否指向同一个实体。C++ 主要由三种链接属性：

外部链接
内部链接
无链接

其中无链接指的是标识符仅存在于当前作用域，完全无法被其他地方访问，例如局部变量、函数参数、非静态类成员等。我们这里讨论的主要是外部链接和内部链接。

2.1 外部链接

具有外部链接的标识符，无论在多少个翻译单元中被声明，都指向同一个唯一的实体，因此可以在一个文件中定义它，然后在其他文件中声明并使用它。

具有外部链接的情况如下：

在函数、类和命名空间之外定义的函数
默认情况下全局变量具有外部链接
类的定义本身具有外部链接，可以在一个文件中定义类，在另一个文件中创建它的实例
类的静态成员变量具有外部链接。

下面是一个很常见的例子：

helper.h：

#ifndef HELPER_H
#define HELPER_H

// 声明一个具有外部链接的变量
// 'extern' 关键字表明 g_shared_data 的定义在别处
extern int g_shared_data;

// 声明一个具有外部链接的函数
void shared_function();

#endif

helper.cpp：

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

// 定义（创建并初始化）这个全局变量
// 这是唯一的定义点
int g_shared_data = 100;

// 定义这个全局函数
void shared_function() 
{
    std::cout << "shared_function() called. g_shared_data is: " << g_shared_data << std::endl;
}

main.cpp：

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

int main() 
{
    std::cout << "main() started. g_shared_data is: " << g_shared_data << std::endl;
    g_shared_data = 200; // 修改共享数据
    shared_function(); // 调用共享函数
    return 0;
}

最终会输出：

main() started. g_shared_data is: 100
shared_function() called. g_shared_data is: 200

这表明 main.cpp 和 helper.cpp 访问和修改的是同一个 g_shared_data 变量。

2.2 内部链接

具有内部链接的标识符，在每个翻译单元中都指向一个独立的、唯一的实体。即使在不同的文件中声明了同名的标识符，它们也是完全不同、互不相干的实体。

具有内部链接的情况如下：

使用 static 关键字修饰的全局变量和函数，这是 C 语言中实现内部链接的传统方式。

// 此变量和函数只在本文件内部可见
static int file_local_count = 10;

static void print_message() 
{
    std::cout << "Message from file1. Count: " << file_local_count << std::endl;
}

匿名命名空间，这是 C++ 中实现内部链接的现代且推荐的方式，使用匿名空间可以避免为每个实体都单独写 static。例如一个名为 greeter.cpp 的内容如下：

#include <iostream>

// greeter.cpp 的匿名命名空间
namespace {
    // 这个 greet() 函数只在 greeter.cpp 文件内有效
    void greet() {
        std::cout << "Hello from greeter.cpp!" << std::endl;
    }
}

// 这是一个普通的、具有外部链接的函数，可以被其他文件调用
void say_hello_from_greeter() {
    // 它调用的是自己文件内部的 greet()
    greet();
}

main.cpp 的内容如下：

#include <iostream>

// main.cpp 的匿名命名空间
namespace {
    // 这个 greet() 函数与 greeter.cpp 中的同名函数完全无关
    // 它只在 main.cpp 文件内有效
    void greet() {
        std::cout << "Hello from main.cpp!" << std::endl;
    }
}

// 声明在 greeter.cpp 中定义的函数
void say_hello_from_greeter();

int main() {
    // 1. 调用当前文件 (main.cpp) 的 greet()
    greet();

    // 2. 调用另一个文件的函数，那个函数会调用它自己的 greet()
    say_hello_from_greeter();

    return 0;
}

最终会输出：

Hello from main.cpp!
Hello from greeter.cpp!

程序顺利运行，没有出现命名冲突的情况，因为不同文件里面的相同名称的函数被各自的匿名空间隐藏了，链接器认为它们是各自私有的，不会发生冲突。

默认情况下 const 全局变量具有内部链接，这个性质是非常重要的，因为这让在头文件中定义常量成为可能。否则多个源文件引用同一个头文件时会有命名冲突。

3. `static`

static 关键字在 C++ 中有多种用途，主要用途包括以下几个方面：

用于修饰静态局部变量：用 static 修饰函数内部的局部变量会改变该变量的存储期。普通局部变量在函数返回时销毁，而静态局部变量是在整个生命周期内都存在的，即使函数退出了也不会被销毁。静态局部变量只有在第一次执行到声明时初始化一次，后续的函数调用会跳过初始化语句。在 C++11 之后的多线程环境下，静态局部变量的初始化过程是线程安全的。
用于修饰静态全局变量或函数：普通的全局变量或函数是具有外部链接性的，可以在其他的项目中通过 extern 关键字访问。如果使用 static 修饰全局变量或函数，则它们的作用域会被限制在单个源文件的内部，变成内部链接。这通常可以用来解决不同文件间因同名全局变量或函数导致的命名冲突问题。

用于修饰类成员：当用 static 修饰类的成员时，它表示该成员属于类本身，而不是特定的对象，所有类的对象共享同一个静态数据成员的实例。静态成员变量必须在类定义之外进行初始化和定义，静态成员函数内部是没有 this 指针，它们只能直接访问类的静态成员变量，不能直接访问非静态成员变量。示例：

#include <iostream>

class Player {
public:
    Player() {
        active_players_++; // 每当创建新玩家时，计数器加一
    }

    ~Player() {
        active_players_--; // 玩家被销毁时，计数器减一
    }

    // 静态成员函数
    static int get_active_players_count() {
        return active_players_;
    }

private:
    // 静态数据成员声明
    static int active_players_;
};

// 静态数据成员的定义和初始化
int Player::active_players_ = 0;
int main() {
    std::cout << "Active players at start: " << Player::get_active_players_count() << std::endl;

    Player p1;
    Player p2;
    std::cout << "Active players now: " << Player::get_active_players_count() << std::endl;

    {
        Player p3;
        std::cout << "Active players inside scope: " << Player::get_active_players_count() << std::endl;
    } // p3 在这里被销毁

    std::cout << "Active players after scope: " << Player::get_active_players_count() << std::endl;

    return 0;
}

4. `extern`

extern 关键字的主要作用是声明一个变量或函数是在别处定义的，主要用于在多个源文件之间共享全局变量和函数。

下面是一个使用 extern 关键字共享全局变量的例子：

config.cpp（定义）：

// 定义一个全局配置变量
int global_log_level = 2; // Definition

config.h（声明）：

#ifndef CONFIG_H
#define CONFIG_H

// 使用 extern 声明全局变量，供其他文件使用
extern int global_log_level; // Declaration

#endif

main.cpp（使用）：

#include <iostream>
#include "config.h" // 包含声明

void some_function() {
    if (global_log_level > 1) {
        std::cout << "High detail logging enabled." << std::endl;
    }
}

int main() {
    some_function();
    global_log_level = 0; // 可以在这里修改它
    std::cout << "Log level set to: " << global_log_level << std::endl;
    return 0;
}

C++ 的函数指针与函数对象

Thu, 03 Jul 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

1. 函数指针

函数指针就是一个指向函数的指针变量，函数是是存放在代码段的，函数指针指向的就是函数在代码段中的入口地址。通过函数指针，我们可以间接地调用这个函数。

语法：

返回类型 (*指针名称)(参数类型1, 参数类型2, ...);

假设我们有一个普通函数：

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

我们可以声明一个指向该函数的函数指针：

int (*p_func)(int, int);
p_func = &add; // & 是可选的，直接写函数名也可以

通过解引用函数指针，或者直接使用指针名，就可以调用它所指向的函数。

// 使用函数指针调用函数
int result1 = (*p_func)(10, 5); // 解引用方式 (C-style)
int result2 = p_func(10, 5);   // 直接使用 (更现代的 C++ 风格)

对于普通函数，add 是函数名，本质是一个标签，指向该函数的入口地址，是静态的，不可改变的。而函数指针是一个变量，它存储的函数的地址，可以通过这个指针去调用函数，是动态的，可以指向不同的函数。基于这个特性，函数指针通常的用途如下：

回调函数 (Callbacks): 一个函数接受另一个函数作为参数，在适当的时候调用它。

void performOperation(int x, int y, int (*op)(int, int)) 
{
std::cout << "Result: " << op(x, y) << std::endl;
}

// 调用
performOperation(20, 10, &add);      // 传入 add 函数
performOperation(20, 10, &subtract); // 传入另一个兼容的函数

实现函数表/跳转表 (Jump Tables): 可以用函数指针数组来代替一长串的 if-else 或 switch-case 语句，根据输入选择要执行的函数。函数指针数组的声明语法如下：
```
返回类型 (*数组名[数组大小])(参数列表);
```
这种声明形式比较晦涩难懂，我们可以使用typedef或using来进行简化：
```
typedef int (*FuncPtr)(int, int);
// 或 C++11 写法：using FuncPtr = int(*)(int, int);

FuncPtr funcArr[3] = {add, sub, mul};
```

函数指针是C语言中的用法，实现简单，调用的开销小。但是在C++中是不推荐使用函数指针的，因为函数指针既不能携带状态信息，也不能捕获或者存储任何上下文的信息。在C++中，通常使用的是函数对象。

2. 函数对象

函数对象又叫仿函数，本质上是一个类或者结构体的实例，由于它重载了operator()，因此我们可以像调用普通函数一样使用这个对象。

一个示例如下：

class Adder 
{
public:
    int operator()(int a, int b) const 
    {
        return a + b;
    }
};
Adder add; // 创建一个 Adder 对象
int sum1 = add(5, 3);       // 像调用函数一样调用对象 add
// 也可以直接创建临时对象并调用
int sum2 = Adder()(10, 20);

函数对象的核心优势在于可以拥有独立的状态，而函数指针和普通函数不具备这个能力。例如：

#include <iostream>
using namespace std;

class Counter 
{
    int count = 0;  // 每个对象独有的状态
public:
    int operator()(int x) {
        return ++count + x;
    }
};

int main() 
{
    Counter c1, c2;
    cout << c1(5) << endl;  // count = 1
    cout << c1(5) << endl;  // count = 2
    cout << c2(5) << endl;  // c2独立，count = 1
}

函数模板允许我们编写与类型无关的泛型代码，当函数模板的行为需要某种可定制的操作时，函数对象便是最理想的参数类型。例如可以写一个通用的getMax函数，可以根据传入的比较策略（函数对象）返回两个值中的较大者。

#include <iostream>
using namespace std;

// 通用比较模板函数
template <typename T, typename Compare>
T getMax(T a, T b, Compare comp) 
{
    return comp(a, b) ? b : a;
}

// 函数对象：比较大小
struct Less 
{
    bool operator()(int a, int b) 
    {
        return a < b; // 返回 true 时，b 是较大者
    }
};

// 函数对象：比较绝对值大小
struct AbsLess 
{
    bool operator()(int a, int b) 
    {
        return abs(a) < abs(b);
    }
};

int main() {
    int x = -5, y = 3;

    // 使用 Less 比较器
    cout << "Max: " << getMax(x, y, Less()) << endl;

    // 使用 AbsLess 比较器
    cout << "Max by abs: " << getMax(x, y, AbsLess()) << endl;

    return 0;
}

在C++的STL算法中，和上面所举例子一样，大量使用了函数对象作为可传递的比较器或操作器，因此STL的使用非常灵活，是泛型编程的典范。例如，C++ 的STL算法std::sort默认的是std::less<T>来进行升序排序，可以使用预定义的函数对象std::greater<T>来进行降序排序：

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional> // 包含预定义函数对象

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

    // 使用 std::greater<> 进行降序排序
    std::sort(nums.begin(), nums.end(), std::greater<int>());

    for (int n : nums) {
        std::cout << n << " "; // 输出: 9 5 4 3 1 1
    }
    std::cout << std::endl;
}

3. Lambda 表达式

C++11 引入的 Lambda 表达式在很多情况下可以看作是创建匿名函数对象的便捷语法，通常编译器会将 Lambda 表达式转换为一个未命名的函数对象。Lambda 表达式的基本格式如下：

[捕获列表](参数列表) -> 返回类型 {
    函数体
};

其中：

[] 捕获列表（Capture List）：捕获列表决定了 Lambda 如何访问外部作用域的变量
- 按值捕获 [=] 或显式 [x, y]：值捕获的变量在 Lambda 表达式定义时就已经确定，不会随着外部变量的变化而变化，例如：
```
int x = 10;
auto f = [x] (int y) -> int { return x + y; }; // 值捕获 x
x = 20; // 修改外部的 x
cout << f(5) << endl; // 输出 15，不受外部 x 的影响
```
  默认情况下，值捕获的变量在lambda内部是只读的，但是可以通过mutable修改，例如：
```
int a = 10;
auto f = [a]() mutable { a++; std::cout << a << std::endl; };
f(); // 输出 11，但外部a仍然是10
```
- 按引用捕获 [&] 或显式 [&x, &y]：引用表达式的变量在 Lambda 表达式调用时才确定，会随着外部变量变化而变化，反之亦然。使用引用捕获要注意生命周期的问题，避免悬空引用。
```
int x = 10;
auto f = [&x] (int y) -> int { return x + y; }; // 引用捕获 x
x = 20; // 修改外部的 x
cout << f(5) << endl; // 输出 25，受外部 x 的影响
```
- 混合捕获：[=, &x]（x按引用，其余按值）或 [&, y]（y按值，其余按引用）。例如：
```
int x = 10;
int y = 20;
auto f = [=, &y] (int z) -> int { return x + y + z; }; // 隐式按值捕获 x，显式按引用捕获 y
x = 30; // 修改外部的 x
y = 40; // 修改外部的 y
cout << f(5) << endl; // 输出 55，不受外部 x 的影响，受外部 y 的影响
```
- 初始化捕获（C++14）：它允许在捕获列表中使用初始化表达式，从而在捕获列表中创建并初始化一个新的变量，而不是捕获一个已存在的变量。这种方式可以使用 auto 关键字来推导类型，也可以显式指定类型。这种方式可以用来捕获只移动的变量，或者捕获 this 指针的值。下面是一个捕获unique_ptr的例子：
```
auto lambda = [p = std::make_unique<int>(42)]() 
{
    std::cout << "Value: " << *p << std::endl;
};
```
- 捕获this指针，[this] 或 [*this]：这允许在 Lambda 内部访问当前类的成员变量和成员函数。this是C++11引入的，这种方式会按值捕获this指针，在 Lambda 表达式的内部会有一份this指针的拷贝，实际上这相当于按引用捕获了对象本身，Lambda 内部对成员变量的修改会直接影响到原始对象。而*this是C++17引入的，这种方式是对当前对象进行值捕获，这就意味着 Lambda 表达式的内部操作的是一个独立的副本，对副本成员的任何修改都不会影响到原始对象。
() 参数列表（Parameter List）：可选，类似于普通函数的参数。
- 与普通函数参数类似，支持默认参数（C++14起）。
- 泛型Lambda（C++14）：使用 auto 声明参数，使 Lambda 可接受任意类型。
-> 返回类型（Return Type）：可选，返回类型通常可以省略，由编译器推导。
{} 函数体（Function Body）：Lambda 的执行逻辑。

Lambda 表达式为我们创建匿名函数对象提供了便捷的语法糖，当我们编写一个Lambda表达式时，C++编译器会自动生成一个独一无二、匿名的类（这个类被称为闭包类型），然后根据这个类创建一个对象，这个对象就是我们所说的函数对象。例如这个 Lambda 表达式：

auto myLambda = [](int x) { return x * 2; };

编译器内部通常会生成如下的匿名类：

// 编译器在内部生成的匿名类
class __SomeInternalUniqueNameForLambda {
public:
    // 1. operator() 的重载
    // Lambda的参数列表和返回类型决定了这个成员函数的签名
    // 默认情况下，这个operator()是const的，因为Lambda默认是不可变的
    int operator()(int x) const {
        return x * 2;
    }
};

// 2. 创建该类的实例（函数对象）
auto myLambda = __SomeInternalUniqueNameForLambda{};

int main() { // 相当于 outer(10) int x = 10;

// 定义闭包，捕获外部变量 x
auto f = [x](int y) { return x + y; };

cout << f(5) << endl;   // 输出 15
cout << f(20) << endl;  // 输出 30

return 0;

}

</Aside>

## 4. 函数包装器和函数适配器

函数包装器`std::function`和函数适配器`std::bind`是C++11引入的两大处理**可调用对象**的强大工具，可以看作是函数指针和函数对象的现代化、类型安全的替代方案。

<Aside type="tip">
**可调用对象**：能用`()`运算符直接调用的对象，都是可调用对象，包括：
- 普通函数
- 函数指针
- 函数对象
- Lambda 表达式
- `std::function` 封装的对象
- `std::bin` 生成的对象

</Aside>

### 4.1 `std::function`

`std::function` 是一个定义在 `<functional>` 头文件中的类模板。它是一个通用的、多态的函数包装器，它可以存储、复制和调用任何签名兼容的可调用对象。`std::function` 的模板参数就是它要包装的函数的签名，语法如下：
```cpp
#include <functional>

std::function<返回类型(参数类型1, 参数类型2, ...)> func;

下面是简单的使用示例：

#include <iostream>
#include <functional>

// 1. 普通函数
int add(int a, int b) { return a + b; }

// 2. 函数对象 (Functor)
struct Subtract 
{
    int operator()(int a, int b) const { return a - b; }
};

int main() 
{
    std::function<int(int, int)> operation;

    // a. 包装普通函数
    operation = add; // 或者 &add
    std::cout << "add(10, 5) = " << operation(10, 5) << std::endl; // 输出 15

    // b. 包装函数对象
    Subtract sub;
    operation = sub;
    std::cout << "subtract(10, 5) = " << operation(10, 5) << std::endl; // 输出 5

    // c. 包装 Lambda 表达式
    operation = [](int a, int b) { return a * b; };
    std::cout << "multiply(10, 5) = " << operation(10, 5) << std::endl; // 输出 50
}

可以看到，它提供了一个统一的接口来存储不同种类的可调用对象，std::function会擦除原始可调用对象的具体类型，只保留其调用的接口。这在设计需要回调的 API 时非常有用。API 的设计者不必为函数指针、函数对象等分别设计接口，只需使用 std::function 即可。由于会进行类型擦除以及可能进行堆分配，std::function的调用可能比直接调用或者通过函数指针调用有轻微的性能开销，std::function对象本身的大小可能比函数指针大。

4.2 `std::bind`

std::bind 也是一个定义在 <functional> 头文件中的函数模板。它的作用是将一个可调用对象（如函数、成员函数、函数对象）与其部分或全部参数进行绑定，从而创建一个新的可调用对象（一个函数对象）。语法如下：

auto new_callable = std::bind(callable, arg1, arg2, ...);

callable_object: 原始的可调用对象。
arg1, arg2, ...:
- 可以是具体的值，这些值将被“绑定”到 callable_object 对应位置的参数。
- 可以是占位符 (Placeholders)，如 std::placeholders::_1, std::placeholders::_2 等。这些占位符表示新生成的可调用对象的参数。_1 对应新可调用对象的第一个参数，_2 对应第二个，以此类推。

一些使用示例如下：

参数绑定（固定部分参数，得到一个参数更少的新函数）：

int add(int a, int b, int c) 
{
    return a + b + c;
}
// 绑定第一个参数为 10
auto add_10 = std::bind(add, 10, std::placeholders::_1, std::placeholders::_2);

重新排列参数顺序：

void print_ordered(int a, const std::string& b, double c) 
{
    std::cout << "Int: " << a << ", String: " << b << ", Double: " << c << std::endl;
}

// 原本参数顺序: int, string, double
// 新函数参数顺序: string, double, int (传入_3)
auto print_reordered = std::bind(print_ordered,
                                std::placeholders::_3, // 第三个参数给 a
                                std::placeholders::_1, // 第一个参数给 b
                                std::placeholders::_2  // 第二个参数给 c
                                );

绑定成员函数：这是std::bind的一个经典用途，用于将成员函数适配为可以独立调用的函数对象。对于非静态成员函数，第一个绑定的参数必须是对象实例的指针或引用，或者是一个包装了对象的std::shared_ptr或std::reference_wrapper。

struct Greeter 
{
    std::string name;
    Greeter(std::string n) : name(n) {}
    void greet(const std::string& salutation) 
    {
        std::cout << salutation << ", " << name << "!" << std::endl;
    }
};

Greeter world_greeter("World");
Greeter cpp_greeter("C++");

// 绑定到 world_greeter 实例的 greet 方法，并预设 salutation 参数
auto greet_world_morning = std::bind(&Greeter::greet, &world_greeter, "Good morning");
greet_world_morning(); // 输出: Good morning, World!

// 绑定到 cpp_greeter 实例的 greet 方法，salutation 通过占位符传入
auto greet_cpp = std::bind(&Greeter::greet, &cpp_greeter, std::placeholders::_1);
greet_cpp("Hello"); // 输出: Hello, C++!

C++ 中的静态库和动态库

Wed, 02 Jul 2025 00:00:00 GMT

在编写程序时，我们为了实现代码复用，通常会把通用的功能模块化，编译成库文件，供其他程序使用。在 C++ 中，库文件分为静态库和动态库两种。

1. 静态库简介

静态库在 Windows 上通常是 .lib 文件，在 Linux 或 macOS 上是.a (archive) 文件。它是一组目标文件（.o 或 .obj 文件）的集合。在程序的链接阶段，链接器会从静态库中提取出程序所需要的所有代码和数据，并将它们完整复制到最终的可执行文件中。编译完成后，即使静态库不存在了，程序也是可以正常运行的。

静态库的优点是独立性强，发布简单。由于所有依赖的代码都被复制到了可执行文件中，所以程序在运行时不再需要外部库文件，可以独立运行，程序的部署和分发更加简单。因为所有代码都在一个文件中，所以可以减少程序在启动时或者调用库函数时的开销。

静态库也有明显的缺点，那就是生成的可执行文件体积较大。因为每个使用该库的程序都包含了一份完整的库代码副本，如果多个程序都使用了同一个静态库，那么在磁盘和内存中就会有多份重复的代码，造成空间浪费。如果静态库进行更新，那么所有使用这个旧版本静态库的程序都必须重新编译、链接，才能得到更新后的代码，这是非常麻烦的。所以静态库在小型软件用得比较多。

2. 动态库简介

动态库在 Windows 上是.dll文件，在 Linux 上是.so文件，在 macOS 上是 .dylib 文件。动态库在程序的链接阶段不会被复制到可执行文件中，链接器只是在可执行文件中记录下对该动态库的引用信息（比如库的名字和函数签名）。当程序运行时，操作系统会根据这些记录的信息，在内存中找到并加载这个动态库。因此所有使用该动态库的程序在内存中是共享同一份库的实例。

多个程序共享同一个动态库，磁盘和内存中只需要存在一份库的副本，大大减少了资源的占用。如果动态库更新了，只需要替换掉系统中的旧库文件即可，所有依赖于它的程序在它下次运行时，就会加载新版本的库，而不需要编译程序本身，但前提是要保持接口兼容。因此大型程序中，通常会拆分出多个较小的动态库模块，按需加载，实现插件化功能。

当然，动态库也是有缺点的。发布程序时，除了可执行文件本身，还必须同时提供其依赖的所有动态库文件，如果用户系统中缺少某个动态库或者版本不兼容，程序将无法运行。这就是我们在 Windows 中有时会碰到“缺少 xxx.dll”的错误。程序启动时需要由操作系统去查找、加载和链接动态库，这会带来一定的性能开销。

3. 静态库的创建

以在 Linux 环境中使用g++编译器创建一个简单的数学计算库为例，静态库的创建一般流程如下：

编写库文件代码，这通常需要包含头文件和源文件。头文件用来声明库对外提供的接口（函数原型），使用我们编写的库则需要包含这个头文件：

#ifndef MATH_LIB_H
#define MATH_LIB_H

// 函数声明：一个加法函数
int add(int a, int b);

// 函数声明：一个减法函数
int subtract(int a, int b);

#endif // MATH_LIB_H

同时，还需要包含源文件，源文件是库函数的具体实现，是不对外暴露的，使用这个静态库的用户无须关心这部分的代码：

#include "math_lib.h"

// 加法函数的实现
int add(int a, int b) {
    return a + b;
}

// 减法函数的实现
int subtract(int a, int b) {
    return a - b;
}

将源文件编译成目标文件(.o)，我们使用g++的-c选项，这个选项告诉编译器只进行编译，生成目标文件，而不进行链接。
```
g++ -c math_lib.cpp -o math_lib.o
```
执行成功后，目录下会多一个math_lib.o文件。如果有多个.cpp文件，则需要都将它们编译成对应的.o文件。

使用ar工具将一个或者多个目标文件打包成静态库，静态库的命名一般遵循lib<库名>.a的规范，例如我们的库叫math，那么库文件应该叫libmath.a

# ar 是一个用于创建和管理归档文件的工具
# rcs 是三个选项的组合：
#   r: replace，若库中已存在同名目标文件，则替换它；若不存在，则添加。
#   c: create，如果库文件不存在，就创建一个。
#   s: create symbol index，为库创建一个索引，可以加快链接速度。
# libmath.a 是我们想要创建的静态库文件名
# math_lib.o 是要打包进去的目标文件
ar rcs libmath.a math_lib.o

将静态库拷贝到系统默认存放库目录下（/usr/lib或/usr/local/lib）这部分是可选的，这通常只用于安装系统级的、供所有用户和程序使用的共享库。如果不拷贝到系统目录，可以在编译主程序时，使用-L选项指定库文件所在的路径。

编写主程序并使用静态库，我们编写如下主程序：

#include <iostream>
#include "math_lib.h" // 包含我们库的头文件

int main() {
    int x = 20;
    int y = 10;

    // 调用静态库中的函数
    int sum = add(x, y);
    int diff = subtract(x, y);

    std::cout << "The sum is: " << sum << std::endl;
    std::cout << "The difference is: " << diff << std::endl;

    return 0;
}

在编译时，如果我们编写的库被拷贝到系统目录中，那我们通常需要使用-L来指定：

# g++: 编译器
# main.cpp: 主程序源文件
# -o main_app: 指定输出的可执行文件名为 main_app
# -I. : -I (大写i) 选项用于指定头文件的搜索路径。'.' 表示当前目录。
#       这样编译器才能找到 #include "math_lib.h"。
# -L. : -L 选项用于指定库文件的搜索路径。'.' 表示当前目录。
#       这样链接器才能找到 libmath.a。
# -lmath: -l (小写L) 选项用于指定要链接的库的名称。
#         编译器会自动在库名前加上 "lib"，在库名后加上 ".a" 或 ".so"。
#         所以 -lmath 就对应着 libmath.a。
g++ main.cpp -o main_app -I. -L. -lmath

4. 动态库的创建

动态库和静态库的创建流程相似，动态库的一般创建流程如下：

和静态库一样，也是需要编写库文件，包括头文件和源文件。
因为动态库运行时会被加载到内存的任意位置，所以它的代码和数据引用不能使用绝对地址，必须使用相对地址，这种代码被称为“位置无关码”（PIC）。需要使用 g++ 的 -fPIC 标志来生成这种代码。
```
g++ -fPIC -c math_lib.cpp -o math_lib.o
```
执行后，会生成名为 math_lib.o 的目标文件。
将刚才生成的位置无关的目标文件链接成一个共享库文件。假设库名为math，仍然遵循lib<name>.so的命名约定。
```
g++ -shared -o libmath.so math_lib.o
```
执行完毕后，当前目录下就会生成 libmath.so 文件，就是我们成功创建的动态库。

编写主程序并使用动态库，我们编写如下主程序：

#include <iostream>
#include "math_lib.h" // 包含我们库的头文件

int main() {
    int x = 20;
    int y = 10;

    // 调用动态库中的函数
    int sum = add(x, y);
    int diff = subtract(x, y);

    std::cout << "The sum is: " << sum << std::endl;
    std::cout << "The difference is: " << diff << std::endl;

    return 0;
}

进行编译：

# -I. 指定头文件搜索路径为当前目录
# -L. 指定库文件搜索路径为当前目录
# -lmath 指定链接名为 "math" 的库 (即 libmath.so)
g++ main.cpp -o main_app -I. -L. -lmath

运行时可能会看到一个这样的错误：

error while loading shared libraries: libmath.so: cannot open shared object file: No such file or directory

因为在运行时，操作系统需要知道去哪里找 libmath.so。编译时使用的 -L. 只是告诉编译器在编译期间去哪里检查库，这个路径信息默认不会被保存到最终的可执行文件中。一般来说有以下三种方法解决这个问题：

将库所在的目录临时添加到 LD_LIBRARY_PATH 环境变量中。
```
# 将当前目录(.)添加到该环境变量中
export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH

# 然后再次运行程序
./main_app
```
export 命令只在当前的终端会话中有效。关闭终端后需要重新设置。因此这是一个临时性的设置，常用于开发当中。
我们可以在编译 main_app 时，把库的路径信息直接“写死”到可执行文件里。这样运行时，程序就知道去哪里找库了。我们使用链接器选项 -rpath。
```
# -Wl,<option> 是告诉g++将<option>传递给链接器(ld)
# -rpath,. 表示将当前目录(.)作为运行时库的搜索路径
g++ main.cpp -o main_app -I. -L. -lmath -Wl,-rpath,.
```
这样程序在运行时会永远在这个路径寻找动态库，比较适用于发布的程序当中。

对于要被系统上很多程序使用的通用库，可以将其安装到标准的系统库目录中，如 /usr/local/lib、/usr/lib和/lib。

# 1. 将库文件拷贝到系统目录 (需要root权限)
sudo cp libmath.so /usr/local/lib/

# 2. 更新系统的动态链接器缓存
sudo ldconfig

# 3. 现在，你可以在任何地方编译和运行你的程序了（编译时仍需-l，但无需-L）
g++ main.cpp -o main_app -lmath

5. 动态库的加载与执行过程

当一个文件被执行时，其内部对动态库的依赖关系必须在运行时得到解析和满足，这个过程是由操作系统的动态链接器来完成的：

启动加载器：操作系统内核首先会读取可执行文件（Linux中为ELF格式）的头部，里面会有一个叫.interp的段，该段指定了动态链接的解释器路径，内核会加载并启动这个动态链接器，并将程序的控制权和相关信息移交给它。
依赖发现与库搜索：动态链接器接管后，会读取可执行文件的.dynamic段，此段包含一系列的DT_NEEDED条目，每个条目都制定了一个必须的共享库名称，动态链接器会按一下顺序去搜索：
- 运行时搜索路径 (rpath、runpath)：这是通过在链接时使用-rpath或-runpath标志指定的。
- LD_LIBRARY_PATH 环境变量：用户可以通过设置此变量，临时性地将一个或多个目录加入到搜索路径中。
- ld.so.cache 缓存：搜索 /etc/ld.so.cache 文件。这是一个由 ldconfig 命令生成的二进制缓存，它索引了配置文件 /etc/ld.so.conf 及其包含的子目录中所有已知的库及其路径。通过缓存进行查找的速度极快。
- 默认库路径：如果以上路径均未找到，链接器会搜索标准的系统默认路径，通常包括 /lib、/usr/lib、/lib64、/usr/lib64。
符号解析与重定位：由于程序代码中对动态库函数或变量的引用只是一个符号名称或者占位符，动态链接器需要将这些符号引用修正为它们在虚拟内存中的实际地址，这个过程主要依赖以下两个机制：
- 全局偏移表 (GOT - Global Offset Table): 存储外部全局变量和函数的绝对地址，代码通过访问GOT来间接访问这些外部符号。
- 过程链接表 (PLT - Procedure Linkage Table): 对外部函数的第一次调用会通过PLT跳转到动态链接器的一段代码，该代码负责查找函数的实际地址，并填入GOT中，后续对同一函数的调用就可以通过PLT直接跳转到GOT记录的实际地址，无需再经过链接器
所有的库成功加载、重定向和初始化后，动态链接器就会将执行控制权交给可执行文件的主入口点。

6. 动态依赖与符号问题排查指南

在我们平时的开发当中，经常会遇到找不到动态库或者找不到符号的问题，下面给出一些常见的排查方法。

运行时找不到动态库文件会报如下信息：

error while loading shared libraries: libxxx.so: cannot open shared object file: No such file or directory

遇到这种问题，我们可以使用ldd命令来列出一个可执行文件或另一个动态库所依赖的所有共享库，并显式动态链接器找到的库路径。

ldd /path/to/your_executable

然后我们可以使用find命令在整个系统中搜索该库文件，并确认它是否真实存在于磁盘上，以及它的具体位置。

# 2>/dev/null 是为了忽略权限不足的错误提示
find / -name "libxxx.so" 2>/dev/null

如果发现库文件存在但是ldd找不到，说明其所在的目录不在动态链接器的搜索路径中，可以使用上面介绍的方法将其加入链接器的搜索路径。

还有一种常见的错误是库文件被成功加载了，但是在执行的过程中，程序需要调用某个函数或者访问某个变量时，发现该符号在库中不存在，典型的报错信息如下：

./your_executable: symbol lookup error: ./your_executable: undefined symbol: _Zxyz...

或者在编译的时候出现：

undefined reference to ...

遇到这种问题，可以使用nm工具列出目标文件或者库文件中的符号，关键是使用 -D 选项来查看动态符号表，因为只有这里的符号才能被外部链接。

# 检查 libxxx.so 是否导出了你需要的符号
nm -D /path/to/libxxx.so | grep 'your_function_name'

C++为了支持函数重载，会把函数名修饰成复杂的符号，因此nm显式的是修饰后的名字，为了查看原始的函数签名，可以使用c++fit解码，可以将 nm 的输出通过管道传给 c++filt 来查看原始的函数签名。

# -n 表示 c++filt 尝试将输入作为符号名处理
nm -D /path/to/libxxx.so | c++filt -n

C++ 中的 malloc、free 和 new、delete

Tue, 01 Jul 2025 00:00:00 GMT

import { Collapse } from 'astro-pure/user'

在C++中，malloc、new、free、delete经常放在一起对比，这里以问答的形式来看看这些关键字的一些细节。

    // 2. 检查分配是否成功
    if (p_int == NULL) 
    {
        printf("内存分配失败！\n");
        return 1; // 返回错误码
    }
    ```
    `free`只需要指定刚刚返回的指针即可，不需要指定大小。
    ```cpp
    free(p_int);
    p_int = NULL; 
    ```
    下面是一个分配数组的例子：
    ```cpp
    int *arr = NULL;
    int n = 5;

    // 1. 为一个包含 n 个整数的数组分配内存
    arr = (int*)malloc(n * sizeof(int));

    // 2. 检查分配是否成功
    if (arr == NULL) 
    {
        printf("数组内存分配失败！\n");
        return 1;
    }

    printf("为 %d 个整数分配了内存。\n", n);

    // 3. 使用内存

    // 4. 释放整个数组的内存
    free(arr);
    printf("数组内存已释放。\n");
    
    arr = NULL;
    ```
- `new`在使用时直接指定要分配的数据类型即可，编译器会自动计算所需的大小，成功时会返回一个对应类型的指针，无需任何转换，如果分配失败则会默认抛出`std::bad_alloc`异常，我们可以使用`try-catch`去捕捉异常。
    ```cpp
    int* p_int1 = new int;//*p_int1 的值是未定义的
    int* p_int2 = new int();//申请内存，并进行初始化
    int* p_int3 = new int(123);//申请内存，并指定一个具体的初始值
    ```
    `new`申请的内存，我们需要用`delete`去释放，只需指定变量名即可：
    ```cpp
    delete p_int1;
    delete p_int2;
    delete p_int3;
    delete p_double;
    ```
    我们可以使用`new[]`去申请一个数组：
    ```cpp
    int* p_array1 = new int[SIZE];// 默认情况下，数组中的元素是未初始化的。
    int* p_array2 = new int[SIZE]{};//可以使用花括号 {} 对数组进行值初始化（所有元素为 0）
    ```
    使用`new[]`申请的数组需要使用`delete[]`去进行释放：
    ```cpp
    delete[] p_array1;
    delete[] p_array2;
    ```

内存处理的差别：
- malloc分配的内存是未初始化的，它仅仅是一块原始的、内容不确定的内存空间。
- new分配的内存是初始化的。对于基本数据类型，初始化的行为取决于new的使用形式，例如new int()会进行值初始化为0，而new int则不保证。对于类类型对象，new会在分配内存后自动调用该类的构造函数，完成对象的初始化工作。
可重载性：
- malloc和free作为C库函数，通常是不可重载的。
- new和delete作为C++的操作符，是可以进行重载的，所以我们可以很方便地定制内存分配策略，比如使用内存池。

// 简洁且安全的写法 delete ptr; // 如果 ptr 是 nullptr，这里什么也不做

</Collapse>

<Collapse title='对一个指针 delete 两次会发生什么？'> 
对一个指针delete两次会导致未定义行为，程序可能会因为内存访问冲突（段错误）而终止，第二次delete可能会破坏内存管理器的内部数据结构，程序不会立即崩溃，后续再申请内存时，由于堆内存结构已经被破坏，会导致莫名的崩溃或者数据错乱。

双重删除避免的传统方法：
```cpp
MyClass* p = new MyClass();

delete p;
p = nullptr;//把指针置为空，这是一个好习惯

// 后续如果不小心再次 delete
delete p; // 这里 p 是 nullptr，所以这行代码是安全的，什么也不会发生。

使用指针指针，能够避免手动管理内存，避免发生这种问题：

#include <memory>

void myFunction() {
    std::unique_ptr<MyClass> p = std::make_unique<MyClass>();
    // ... 使用 p ...
} // p 离开作用域，MyClass 对象被自动删除，绝不会发生双重删除

C++ 中的 RAII 思想

Mon, 30 Jun 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

RAII 是 “Resource Acquisition Is Initialization” 的缩写，中文通常翻译为 “资源获取即初始化”。这是 C++ 语言中的一种重要编程范式。

1. 核心思想

RAII的核心思想是将资源的生命周期与对象的生命周期绑定起来。具体来说：

获取资源：在对象的构造函数中获取资源。当对象被成功创建时，资源也就被成功获取了。
使用资源：在对象的生命周期内，可以通过对象的方法来使用该资源。
释放资源：在对象的析构函数中释放资源。当对象离开其作用域（例如，函数返回、对象被 delete、栈展开等）时，其析构函数会自动被调用，从而确保资源被释放。

2. RAII的优点

由于C/C++是需要手动管理资源的语言，保证在任何情况下都能正确释放资源是一个非常大的挑战，例如：

函数提前返回：一个函数可能有多个返回路径，函数可能提前返回，导致资源没有被正确释放。

void process_data_bad(int size) 
{
    // 获取资源
    int* data = (int*)malloc(size * sizeof(int));
    // 检查一个条件，可能导致提前返回
    if (size <= 0) 
    {
        std::cout << "Invalid size, returning early.\n";
        // 错误：在这里返回，但没有释放内存！
        return;
    }
    // ... 使用 data ...
    std::cout << "Processing data...\n";
    //手动释放资源
    free(data);
}

异常抛出：如果在获取资源后，在释放前发生了异常，正常的清理代码会被跳过，导致资源发生泄露。

void process_with_exception_bad() 
{
    // 获取资源
    char* buffer = new char[1024];
    std::cout << "Buffer allocated.\n";
    try 
    {
        // ... 使用 buffer ...
        do_some_work(true); // 模拟一个操作抛出异常
        // 异常发生后，下面的代码不会执行
        std::cout << "This line will not be printed.\n";
        delete[] buffer; // 释放代码被跳过！
    } 
    catch (const std::exception& e) 
    {
        std::cout << "Caught exception: " << e.what() << "\n";
        // 我们在这里捕获了异常，但 buffer 已经泄漏了！
    }
}

复杂的逻辑分支：在多层的if-else循环中，要确保所有可能的代码路径上都释放资源，代码会变得非常混乱且容易出错。

void complex_logic_bad(const char* filename, int condition) 
{
    // 获取资源
    FILE* file = fopen(filename, "w");
    if (!file) 
    {
        return;
    }
    if (condition == 1) 
    {
        fprintf(file, "Condition 1");
        // ... 更多操作
        if (/* 某个子条件 */ true) {
            fclose(file); // 清理点 1
            return;
        }
    } 
    else if (condition == 2) 
    {
        for (int i = 0; i < 5; ++i) 
        {
            if (i == 3) 
            {
                fprintf(file, "Breaking loop");
                fclose(file); // 清理点 2
                return; // 用 return 代替 break
            }
        }
    } 
    else 
    {
        fprintf(file, "Default condition");
        // 假设这里一切正常
    }
    // 最终的清理点
    fclose(file); // 清理点 3
}

在这些情况下，忘记或者无法调用释放资源的代码都会导致资源泄漏。而通过RAII的思想可以避免以上情况的发生，RAII主要有以下优点：

自动资源管理和防止泄漏：这是 RAII最核心的优点。资源在对象销毁时自动释放，作为程序员的我们不需要手动调用释放资源的函数，如free()、fclose()、close_socket()、pthread_mutex_unlock()等，这可以极大降低忘记释放资源导致资源泄漏的风险。
异常安全：如果在资源被获取后、显示释放代码执行前发生异常，传统的try-catch-finally很容易出错或者发生遗漏。如果我们使用RAII，异常发生会导致栈展开，作用域内的析构函数会被异常调用，保证了资源能够被正确释放。
代码简洁和可读性：RAII把资源管理都封装在了专门的类中，使得业务代码逻辑代码更加干净整洁。

3. RAII的经典例子

C++标准库本身就是RAII思想的最佳实践者，下面是一些经典示例：

智能指针：std::unique_ptr，std::shared_ptr和std::weak_ptr是RAII的完美体现。它们在构造时获取动态分配的内存（或接管已分配的内存），并在析构时自动释放这块内存。

#include <memory>
#include <stdexcept>

void good_function() 
{
    // 资源获取（内存分配）即初始化
    std::unique_ptr<int> ptr(new int(42));

    // ... 其它操作
    if (/* 某个条件失败 */) 
    {
        // ptr 离开作用域，其析构函数被调用，自动 delete 内存
        return;
    }
    if (/* 某个操作抛出异常 */) 
    {
        // 发生异常，栈展开，ptr 的析构函数被调用，自动 delete 内存
        throw std::runtime_error("Something went wrong!");
    }
    // ... 其它操作

} // 函数正常结束，ptr 离开作用域，析构函数被调用，自动 delete 内存

文件处理：std::fstream，std::ifstream，std::ofstream类就是RAII的例子。它们在构造时打开文件，在析构时自动关闭文件。

#include <fstream>
#include <string>
#include <iostream>

void write_to_file(const std::string& filename) 
{
    // 构造 ofstream 对象时，文件被打开（获取资源）
    std::ofstream file(filename);
    if (!file.is_open()) 
    {
        std::cerr << "Failed to open file.\n";
        return;
    }

    file << "Hello, RAII!\n";
    // ... 可能发生异常

} // 函数结束，file 对象被销毁，其析构函数自动调用 file.close()

互斥锁：std::lock_guard和std::unique_lock是用于管理互斥锁的RAII包装器。它们在构造时锁定互斥锁，在析构时自动解锁互斥锁，确保即使在临界区发生异常，锁也会被释放，避免死锁。

#include <mutex>

std::mutex mtx;

void safe_critical_section() 
{
    // 构造 lock_guard 时，自动调用 mtx.lock()
    std::lock_guard<std::mutex> guard(mtx);

    // ... 执行临界区代码
    if (/* 某个条件 */) 
    {
        // guard 离开作用域，其析构函数自动调用 mtx.unlock()
        return;
    }
    // ... 即使这里抛出异常，析构函数也会被调用

} // 函数结束，guard 被销毁，析构函数自动调用 mtx.unlock()

4. RAII类的实现

如果我们想实现一个RAII类，一般的步骤如下：

确定资源：明确要使用这个类管理什么资源，这个资源必须有清晰的获取和释放操作，例如：fopen/fclose、new/delete、lock/unlock。
定义类骨架：定义一个类，并将代表资源的句柄作为其私有成员变量。
实现构造函数：在构造函数中执行获取资源的操作，构造函数应该接收所有获取资源所必须的参数，获取资源后将句柄存放在成员变量中。同时要处理资源获取失败的情况。
实现析构函数：在析构函数中执行释放资源的操作，析构函数应该检查句柄是否有效。
管理所有权：通常来说，应该RAII对象应该独占它所管理的资源，所以我们应该禁止拷贝构造函数和拷贝赋值运算符，防止两个对象管理同一个资源，避免一个资源被释放两次。通常我们还会实现移动构造函数和移动赋值运算符，允许资源所有权从一个对象转移到另一个对象，既高效又安全。
提供访问接口：RAII类是资源的“管理者”，而不是资源本身。需要提供方法让外部能够使用被管理的资源，例如提供一个get()方法返回原始句柄，或者重载 ->和*运算符。

下面是创建一个RAII类管理C风格的文件句柄的例子：

#include <cstdio>    //管理文件的C函数：FILE、fopen、fclose、fputs
#include <utility>   //引入std::move
#include <stdexcept> //异常处理

class FileGuard
{
private:
    FILE *m_file_handle = nullptr; // 用来存储文件句柄
public:
    // 在构造函数中获取资源，析构函数接收文件名和打开模式作为参数
    explicit FileGuard(const char *filename, const char *mode)
    {
        // 获取资源
        m_file_handle = fopen(filename, mode);
        // 如果fopen失败，抛出异常
        if (m_file_handle == nullptr)
        {
            throw std::runtime_error("Failed to open file: " + std::string(filename));
        }
        printf("FileGuard: File '%s' opened.\n", filename);
    }
    // 在析构函数中释放资源
    ~FileGuard()
    {
        if (m_file_handle != nullptr)
        {
            printf("FileGuard: Closing file.\n");
            fclose(m_file_handle);
            m_file_handle = nullptr; // 将句柄设为nullptr为了防止意外使用
        }
    }
    // 删除拷贝构造函数
    FileGuard(const FileGuard &) = delete;
    // 删除拷贝赋值运算符
    FileGuard &operator=(const FileGuard &) = delete;
    // 实现移动构造函数
    FileGuard(FileGuard &&other) noexcept : m_file_handle(other.m_file_handle)
    {
        // 这里把源对象的析构函数的句柄置为nullptr，源对象析构的时候就不会关闭文件了
        other.m_file_handle = nullptr;
        printf("FileGuard: Ownership moved (move constructor).\n");
    }
    // 实现移动赋值运算符
    FileGuard &operator=(FileGuard &&other) noexcept
    {
        // 防止自我赋值，例如：my_file=std::move(my_file)
        if (this != &other)
        {
            // 释放当前对象可能持有的资源
            if (m_file_handle != nullptr)
            {
                fclose(m_file_handle);
            }
            // 转移资源所有权
            m_file_handle = other.m_file_handle;
            other.m_file_handle = nullptr;
            printf("FileGuard: Ownership moved (move assignment).\n");
        }
        return *this;
    }
    // 提供访问结果，返回文件句柄，便于进行文件操作
    FILE *get() const
    {
        return m_file_handle;
    }
    // 提供一个简单的方法，判断文件是否成功打开
    explicit operator bool() const
    {
        return m_file_handle != nullptr;
    }
};

参考资料

C++ RAII 思想机制详解 | 编程指北-计算机学习指南

C++ 的 sizeof 运算符

Sun, 29 Jun 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

1. `sizeof`运算符简介

sizeof是C++中的一个关键字和一元运算符，其作用是取得数据类型或者表达式的大小（以Byte为单位），求得结果的类型是std::size_t。它是一个编译时运算符，在绝大多数情况下是在编译时进行运算（在运行时运算的特例后面会提及）。sizeof运算符的语法有两种形式：

对类型使用：必须使用括号
```
sizeof(type)
```
例如：sizeof(int)、sizeof(double)
对表达式使用：括号是可选的
```
sizeof expression
// 或者
sizeof(expression)
```
例如：sizeof(x)、sizeof(x+1)

2. `sizeof`运算符的常见用法

sizeof运算符可以求得基本数据类型的大小，例如：
```
sizeof(char);//结果为1
```
对变量使用sizeof，可以求得该变量类型的大小，例如：
```
int a;
sizeof a;//结果为4
```

对数组使用sizeof，可以求得整个数组的长度，一个常见的用法是计算数组中元素的数量，例如：

int arr[] = {1, 2, 3, 4, 5, 6, 7};
int numElements = sizeof(arr) / sizeof(arr[0]);
std::cout << "Number of elements: " << numElements << std::endl; // 输出: 7

对指针变量使用sizeof，可以求得指针本身的大小。对引用使用sizeof，可以求得被引用对象的大小，而不是引用本身的大小，例如：
```
int* p = nullptr;
sizeof p;//结果为8（64位系统）或4（32位系统）

int x = 10;
int& ref = x;
sizeof ref;//结果为4
```
对类或者结构体使用sizeof，可以求得该类或者结构体的一个对象占用的总字节数，通常包括：
- 非静态成员变量的大小
- 编译器为了内存对齐而额外添加的字节
- 如果存在虚函数，会包含一个指向虚函数表的虚指针大小
不包括：
- 静态成员变量的大小，因为静态成员变量不属于任何一个对象，而是由所有对象共享
- 成员函数的大小，因为成员函数存储在代码段，不占用对象的内存空间
// 在一个典型的64位系统上，sizeof(MyClass) 可能是 24 字节 // (vptr: 8) + (int a: 4) + (char b: 1) + (padding: 3) + (double c: 8) = 24
```
在C++中，由于任何对象都必须有一个唯一地址，因此空类和结构体的大小至少为1字节，例如：
```cpp
class Empty {};
std::cout << "Size of Empty class: " << sizeof(Empty) << std::endl; // 输出: 1
```

3. `sizeof`运算符的一些特性

sizeof是运算符而不是函数，这是sizeof最基本的特性。因此我们通常不会采用参数和返回值的说法。
sizeof不能求得void类型的长度，因为void类型是没有大小的，我们也无法声明void类型的变量。sizeof能够求得void类型的指针的长度，因为void类型的指针是有大小的。
```
sizeof(void);//非法
sizeof(void*)//合法
```

对任何类型的指针变量使用sizeof，得到的永远是指针本身的大小，而不是它所指向的对象或内存块的大小。例如：

int arr[10];
int *p = arr;
std::cout << sizeof(arr) << std::endl; // 输出：10 * sizeof(int) = 40
std::cout << sizeof(p) << std::endl;   // 输出：指针大小，通常是 4 或 8 字节

在函数参数中，数组会退化成指针，因为在函数参数传递时，数组被退化成指针了，例如：

void func(int arr[10]) 
{
    std::cout << sizeof(arr) << std::endl; // 实际是 sizeof(int*)，而不是数组大小
}
int main() {
    int arr[10];
    func(arr);
}

表达式不会被求值，但是会返回表达式计算结果的类型大小。例如：

int x = 5;
double y = 5.0;
std::cout << sizeof(x++) << std::endl; // 结果为4，x 仍然等于 5
std::cout << sizeof(x+y) << std::endl; //结果为8，求得的是double的大小

动态内存只能求得指针大小，无法获取内存块的大小，例如：

int *p = new int[10];
std::cout << sizeof(p) << std::endl; // 结果是 4 或 8，无法获取数组总大小

sizeof用在函数调用上时，实际上不会调用函数，只会求得函数的返回类型所占用的字节数，例如：
```
int foo() 
{
    std::cout << "foo() 被调用" << std::endl;
    return 42;
}

int main() {
    std::cout << sizeof(foo()) << std::endl;//输出结果为4
    return 0;
}
```
这是因为sizeof的运算是在编译器完成的，不会产生任何的运行时行为。注意sizeof不能对void函数使用，因为返回值void是没有大小的，编译会报错。

sizeof不能用来获取结构体中单个位域成员的大小，sizeof只能针对类型或者整个结构体，不能直接用于单个位域成员，例如：

struct Test 
{
    unsigned int a : 3;  // 3 bits
    unsigned int b : 5;  // 5 bits
};

int main() 
{
    Test t;
    std::cout << sizeof(t.a) << std::endl; // 输出 4（因为 a 是 unsigned int 类型）
    std::cout << sizeof(t) << std::endl;   // 输出结构体的总大小，通常会考虑对齐
    return 0;
}

sizeof不能对不完整类型的数组求长度，会导致编译错误，例如：

int arr[];  // 只声明，不定义（大小未知）
int main() {
    std::cout << sizeof(arr) << std::endl;  // 编译错误，类型不完整
}

对字面量使用sizeof会包含\0，例如：

std::cout << sizeof("hello") << std::endl; // 输出 6，包括 '\0'

4. `sizeof`的其他常见问题

sizeof是有可能是在运行时计算的，这只发生在一种非常特殊的情况下，即对变长数组使用sizeof时。在标准的C++中，sizeof的结果始终都是一个编译时常量，编译器在编译代码时就已经确定了所有类型的大小，并将sizeof的结果替换成为一个具体数值。

变成数组是C99语言的一个特性，它允许使用一个变量来指定数组的长度：

// 这是 C 语言代码，不是标准 C++
void foo(int n) {
    int array[n]; // n 的值在运行时才知道，所以 array 是一个变长数组
}

但是我们会发现，我们在C++这样写不会报错，因为一些主流的C++编译器（特别是GCC和Clang）为了向后兼容C语言，把VLA作为一种非标准的语言扩展也引入到了C++中。所以在这种情况下，对变长数组使用sizeof是运行时进行计算的。

参考资料

C/C++中 sizeof 详解 - 一杯清酒邀明月 - 博客园

C++ 中的内存对齐

Sat, 28 Jun 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

1. 内存对齐简介

在讨论内存对齐之前，我们先来看一下计算机底层是怎么对数据进行存取的，这涉及到计算机组成原理的知识。

这主要涉及计算机中的三大总线：地址总线、数据总线和控制总线。地址总线决定数据的地址，数据总线里面传输的是数据，控制总线传输的是命令和状态信号。数据总线的宽度直接决定了一个CPU周期可以同时传送多少位。CPU的设计是高度协同的，寄存器和数据总线的宽度一般相同（Intel早期的8086的寄存器宽度为16位，总线宽度为8位），我们平时所说的xx位的计算机实际上指的是CPU寄存器的宽度，例如：

32位计算机：CPU寄存器和数据总线的宽度都为32位
64位计算机：CPU寄存器和数据总线的宽度都为64位

现代计算机中，内存空间的最小单位是字节，因为CPU的地址总线以字节为最小寻址粒度。但是，大部分的处理器并不是按字节来存取内存的，一般会以2字节，4字节，8字节来存取内存，我们称之为内存存取粒度。这个存取的宽度就取决于我们上面介绍的总线宽度，例如32位计算机每次传输的是32位（4字节），而64位计算机每次传输的是64位（8字节）。

以32位计算机为例，假设我们要在0x0001这个地址中写入一个字符'A'（1字节）。CPU会将0X0000放在地址总线，让内存控制器知道目标在0x0000到0x0003那个内存块，然后会将字符'A'放在数据总线的对应位置，即4字节块中的第二个字节，CPU会使能第二天字节使能线，这个控制指令放在控制总线中，这样CPU可以在对应的位置写入而不影响内存块中的其他字节。

再举个例子，假设在一个32位的计算机中，要读取一个地址为0x1001的int变量，那么这个4字节的int变量占用的内存是0x1001 - 0x1005。由于32位计算机的内存存取粒度是4，因此该处理器只能从地址为4的倍数的内存开始读取数据。第一次会读取0x1000 - 0x1003，剔除不需要的字节（0x1000），然后第二次读取0x1004 - 0x1007，剔除不要的数据（0x1005、0x1006、0x1007），最后将数据合并完成读取。

那内存对齐是什么呢？其实内存对齐是一种优化技术，旨在提高CPU访问内存的速度，从以上的例子可以看出，虽然int的大小等于内存存取粒度，但是由于存放的位置，CPU需要进行两次读取。而内存对齐则是对数据再内存中存放的位置的限制，通常会要求数据的首地址的值是某个数k的倍数。例如如果规定int的首地址只能是4的倍数，那么对int的读取就可以一次性完成。

2. 内存对齐规则

一些核心概念如下：

自身对齐值：这是数据类型本身固有的对齐要求，通常等于其 sizeof 的大小。
- char: 1 字节
- short: 2 字节
- int: 4 字节
- float: 4 字节
- double: 8 字节
- long: 4 字节（32为系统）或 8 字节（64位系统）
- long long: 8 字节
- 指针: 4 字节（32位系统）或 8 字节（64位系统）
指定对齐值：这是程序员通过编译器指令（如 C/C++ 中的 #pragma pack(n)）手动设定的对齐值。n 的值通常是1, 2, 4, 8等2的幂。
有效对齐值 (Effective Alignment)：这是编译器最终为某个数据成员采用的对齐值。它的计算规则是：有效对齐值 = Min(自身对齐值, 指定对齐值)。

所有的数据结构，无论是struct还是union，在布局时都遵循以下三条规则：

结构体中每个成员相对于结构体起始地址的偏移量，必须是其有效对齐值的整数倍。如果不是，编译器会在前一个成员后面填充若干字节以满足要求。
结构体（或联合体）的总大小，必须是其所有成员中最大的有效对齐值的整数倍。如果不是，编译器会在最后一个成员后面填充若干字节以满足要求。
如果一个结构体包含了另一个嵌套结构体，那么这个嵌套结构体的起始偏移量，必须是其内部所有成员中最大的有效对齐值的整数倍。

3. 内存对齐举例

在64位系统中，一个结构体定义如下：

struct MyStruct {
    char a;         // 自身对齐1
    int b;          // 自身对齐4
    double c;       // 自身对齐8
    short d;        // 自身对齐2
};

第一个成员a，有效对齐值为1，当前偏移量为0，是1的倍数，因此当前大小为1字节。
第二个成员b，有效对齐值4，当前偏移量为1，不是4的倍数，前面要填充3字节，因此当前大小为8字节。
第三个成员c，有效对齐值为8，当前偏移量为8，是8的倍数，因此当前大小为16字节。
第四个成员d，有效对齐值为2，当前偏移量为10，是2的倍数，因此当前大小为18字节。
在结构体中，最大有效对齐值为8，18不是8的倍数，需要填充到24，后面填充6个字节。

因此这个结构体在内存中的布局如下：

下面举一个指定对齐值的例子：

#pragma pack(push, 2) // 设置指定对齐值为2
struct MyStructPacked {
    char a;         // 自身对齐1->有效对齐min(1,2)=1
    int b;          // 自身对齐4->有效对齐min(4,2)=2
    double c;       // 自身对齐8->有效对齐min(8,2)=2
    short d;        // 自身对齐2->有效对齐min(2,2)=2
};
#pragma pack(pop) // 恢复默认

第一个成员a，有效对齐值为1，当前偏移量为0，是1的倍数，因此当前大小为1字节。
第二个成员b，有效对齐值为2，当前偏移量为1，不是2的倍数，前面要填充1字节，因此当前大小为6字节。
第三个成员c，有效对齐值为2，当前偏移量为6，是2的倍数，因此当前大小为14字节。
第四个成员d，有效对齐值为2，当前偏移量为14，是2的倍数，因此当前大小为16字节。
在结构体中，最大有效对齐值为2，16是8的倍数，不需要再填充，因此总大小为16字节。

因此这个结构体在内存中的布局如下：

二叉树的遍历小结

Thu, 19 Jun 2025 00:00:00 GMT

import { Aside } from 'astro-pure/user'

1. 二叉树的遍历方式

二叉树的遍历方式可以分为深度遍历和广度遍历两种。

所谓的深度遍历，就是深度优先的原则，先把一条路径走到头再回头，对于二叉树就是选择一条路径走到叶子节点之后再考虑其他路径。二叉树的深度遍历又可以分为前序遍历、中序遍历、后序遍历三种，这三种遍历方式的访问顺序分别为：

前序遍历：根节点->左子树->右子树
中序遍历：左子树->根节点->右子树
后序遍历：左子树->右子树->根节点

而所谓的广度遍历，就是广度优先的原则。对于二叉树来说，就是一层一层地访问，所以又叫层序遍历。

以下面这个二叉树为例：

前序遍历：1->2->4->5->6->7->3->8->9
中序遍历：4->2->6->5->7->1->3->9->8
后序遍历：4->6->7->5->2->9->8->3->1
层序遍历：1->2->3->4->5->8->6->7->9

2. 二叉树遍历的代码实现

在遍历之前，先定义节点，以及构建上面示例的二叉树。

节点定义：

//节点定义
struct TreeNode
{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int val):val(val),left(nullptr),right(nullptr){}
};

构建二叉树：

TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
root->right->right = new TreeNode(8);
root->left->right->left=new TreeNode(6);
root->left->right->right=new TreeNode(7);
root->right->right->left=new TreeNode(9);

在下面的代码中，我们打印出节点的值来表示真正的访问（下面统称为记录）。那什么不是真正的访问呢？对于上面举例的那棵二叉树，后序遍历先访问节点4，但是在代码中我们需要先经过1->2->4这样的路径到达4。

但是在经过1和2的时候，我们没有记录节点的值，并不是“真正的访问”。

2.1 前序遍历

先来看递归版本：

//前序遍历递归版本
void preorder_recursion(TreeNode* root)
{
    if(root==nullptr)
    {
        return ;
    }
    cout<<root->val<<" ";
    preorder_recursion(root->left);
    preorder_recursion(root->right);
}

因为深度优先的的原则通常是用递归来实现的，因此递归的代码非常简单。当到达某个节点时，我们将它的val值打印出来，即记录该节点的值。根据前序遍历的定义，我们先访问根节点的值，然后访问左子树，再访问右子树。所以在递归访问左子树之前，就需要记录根节点的值。

现在来看迭代版本，所谓的迭代版本，就是不借助递归调用函数来实现，递归的时候隐式地维护了一个栈，迭代版本就是显式地把这个栈模拟出来。前序遍历的迭代版本如下：

//前序遍历迭代版本
void preorder_iteration(TreeNode* root)
{
    stack<TreeNode*> st;
    while(!st.empty()||root!=nullptr)
    {
        while(root!=nullptr)
        {
            cout<<root->val<<" ";//记录根节点的值
            //将根节点入栈，这里入栈是为了访问完左子树之后，能够根据根节点去访问右子树
            st.push(root);
            root=root->left;//访问左子树，
        }
        //左子树访问完之后，根节点出栈
        root=st.top();
        st.pop();
        root=root->right;//访问右子树
    }
}

2.1 中序遍历

先来看递归版本：

//中序遍历递归版本
void inorder_recursion(TreeNode* root)
{
    if(root==nullptr)
    {
        return ;
    }
    inorder_recursion(root->left);
    cout<<root->val<<" ";
    inorder_recursion(root->right);
}

中序遍历的递归版本的代码和前序遍历非常相似，只是记录节点的位置不同。根据定义，先访问左子树，再访问根节点，最后再访问右子树，因此记录根节点的位置在中间。

中序遍历的迭代版本如下：

//中序遍历迭代版本
void inorder_iteration(TreeNode* root)
{
    stack<TreeNode*> st;
    while(!st.empty()||root!=nullptr)
    {
        while(root!=nullptr)
        {
            //根节点入栈，为了能够访问完左子树之后，能够访问根节点和右子树
            st.push(root);
            root=root->left;//访问左子树
        }
        root=st.top();
        st.pop();
        cout<<root->val<<" ";//记录根节点的值
        root=root->right;//访问右子树
    }
}

中序遍历和前序遍历的迭代版本也非常相似，只是记录根节点的顺序不同。根据定义，中序遍历先访问左子树再访问根节点，因此记录根节点的位置放在了出栈的时候而不是入栈的时候。

其实这可以结合递归版本来理解的。前序遍历的递归版本在调用递归函数访问左子树之前，已经记录了根节点的值，而调用递归函数恰恰是入栈的过程。而中序遍历的递归版本在调用递归函数访问左子树之后，再记录根节点的值，即出栈之后。

2.3 后序遍历

先来看递归版本：

//后序遍历递归版本
void postorder_recursion(TreeNode* root)
{
    if(root==nullptr)
    {
        return ;
    }
    postorder_recursion(root->left);
    postorder_recursion(root->right);
    cout<<root->val<<" ";
}

递归版本非常好理解，递归访问完左子树和右子树之后，记录根节点的值。

迭代版本如下：

//后序遍历迭代版本
void postorder_iteration(TreeNode* root)
{
    stack<TreeNode*> st;
    TreeNode* prev=nullptr;
    while (!st.empty()||root!=nullptr)
    {
        while(root!=nullptr)//递归访问左子树
        {
            st.push(root);
            root=root->left;
        }
        //访问完左子树之后
        root=st.top();//根节点出栈
        st.pop();
        //判断右子树是否已经访问了，如果右子树为空或者右子树已经访问了
        //则记录根节点的值。
        if(root->right==nullptr||prev==root->right)
        {
            cout<<root->val<<" ";
            prev=root;
            //这里的置空是为了在下一次循环中从栈中获取节点进行处理
            //而不是继续处理当前节点，因为记录了当前节点之后，
            //说明左右子树的节点都已经被处理完了
            root=nullptr;
        }
        //否则访问右子树
        else
        {
            st.push(root);
            root=root->right;
        }
    }
    
}

后序遍历的迭代版本是所有的遍历中最难理解的。我们先从后序遍历的递归版本看起，递归版本先递归访问左子树，再递归访问右子树后，再记录根节点的值。递归访问左子树在迭代中的实现：

while(root!=nullptr)
{
    st.push(root);
    root=root->left;
}

这部分代码就是实现了递归访问左子树。后序遍历为什么和前序遍历和中序遍历有这么大差别呢？主要原因是记录值的位置不同，前序遍历在递归访问左子树前记录根节点的值，中序遍历在递归访问左子树后记录根节点的值。而后序遍历，在递归访问完左子树后，再递归访问右子树和记录节点的值。

在递归代码中，“再递归访问右子树和记录节点的值” 这个是很容易实现的，而在迭代版本中，递归的返回即是根节点的出栈，这时我们就需要判断右子树是否已经访问过了。如何判断呢？这里的方法是引入一个名为prev的辅助变量，记录上一次访问的节点。如果从栈弹出的节点的右孩子等于 prev 这个辅助变量，说明访问的就是右子树，可以对当前节点进行记录了，否则需要访问右子树。

对于后序遍历，网上还有一种做法利用一种异构的前序遍历(中->右->左)遍历二叉树后，再将结果翻转得到后序遍历的结果。这种做法看似优雅，其实本质上还是前序遍历，而不是后序遍历。遍历算法的本质，不是看最后输出的那一串有序的数字的顺序，而是一种有序的内存访问顺序。 失去了访问顺序，即使用各种数据结构恢复这个次序，遍历的本身也毫无意义。

2.4 层序遍历

层序遍历是广度优先的思想，广度优先遍历一般借助队列实现，代码如下：

//层序遍历
void levelorder(TreeNode* root)
{
    if(root==nullptr)
    {
        return;
    }
    queue<TreeNode*> q;
    q.push(root);
    while(!q.empty())
    {
        int sz=q.size();//获取当前层的节点个数
        for(int i=0;i<sz;i++)//对当前层进行遍历
        {
            TreeNode* node=q.front();
            q.pop();
            cout<<node->val<<" ";
            if(node->left) q.push(node->left);
            if(node->right) q.push(node->right);
        }
        cout<<endl;
    }
}

3. 代码汇总

#include <iostream>
#include <vector>
#include <stack>
#include <queue>

using namespace std;

//节点定义
struct TreeNode
{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int val):val(val),left(nullptr),right(nullptr){}
};

//前序遍历递归版本
void preorder_recursion(TreeNode* root)
{
    if(root==nullptr)
    {
        return ;
    }
    cout<<root->val<<" ";
    preorder_recursion(root->left);
    preorder_recursion(root->right);
}

//前序遍历迭代版本
void preorder_iteration(TreeNode* root)
{
    stack<TreeNode*> st;
    while(!st.empty()||root!=nullptr)
    {
        while(root!=nullptr)
        {
            cout<<root->val<<" ";//记录根节点的值
            //将根节点入栈，这里入栈是为了访问完左子树之后，能够根据根节点去访问右子树
            st.push(root);
            root=root->left;//访问左子树，
        }
        //左子树访问完之后，根节点出栈
        root=st.top();
        st.pop();
        root=root->right;//访问右子树
    }
}

//中序遍历递归版本
void inorder_recursion(TreeNode* root)
{
    if(root==nullptr)
    {
        return ;
    }
    inorder_recursion(root->left);
    cout<<root->val<<" ";
    inorder_recursion(root->right);
}

//中序遍历迭代版本
void inorder_iteration(TreeNode* root)
{
    stack<TreeNode*> st;
    while(!st.empty()||root!=nullptr)
    {
        while(root!=nullptr)
        {
            //根节点入栈，为了能够访问完左子树之后，能够访问根节点和右子树
            st.push(root);
            root=root->left;//访问左子树
        }
        root=st.top();
        st.pop();
        cout<<root->val<<" ";//访问根节点
        root=root->right;//访问右子树
    }
}

//后序遍历递归版本
void postorder_recursion(TreeNode* root)
{
    if(root==nullptr)
    {
        return ;
    }
    postorder_recursion(root->left);
    postorder_recursion(root->right);
    cout<<root->val<<" ";
}

//后序遍历迭代版本
void postorder_iteration(TreeNode* root)
{
    stack<TreeNode*> st;
    TreeNode* prev=nullptr;
    while (!st.empty()||root!=nullptr)
    {
        while(root!=nullptr)//递归访问左子树
        {
            st.push(root);
            root=root->left;
        }
        //访问完左子树之后
        root=st.top();//根节点出栈
        st.pop();
        //判断右子树是否已经访问了，如果右子树为空或者右子树已经访问了
        //则记录根节点的值。
        if(root->right==nullptr||prev==root->right)
        {
            cout<<root->val<<" ";
            prev=root;
            //这里的置空是为了在下一次循环中从栈中获取节点进行处理
            //而不是继续处理当前节点，因为记录了当前节点之后，
            //说明左右子树的节点都已经被处理完了
            root=nullptr;
        }
        //否则访问右子树
        else
        {
            st.push(root);
            root=root->right;
        }
    }
    
}

//层序遍历
void levelorder(TreeNode* root)
{
    if(root==nullptr)
    {
        return;
    }
    queue<TreeNode*> q;
    q.push(root);
    while(!q.empty())
    {
        int sz=q.size();//获取当前层的节点个数
        for(int i=0;i<sz;i++)//对当前层进行遍历
        {
            TreeNode* node=q.front();
            q.pop();
            cout<<node->val<<" ";
            if(node->left) q.push(node->left);
            if(node->right) q.push(node->right);
        }
        cout<<endl;
    }
}

//删除二叉树
void deleteTree(TreeNode* node) {
    if (node == nullptr) return;
    
    deleteTree(node->left);
    deleteTree(node->right);
    
    delete node;
}

int main() {
    // 构建二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->right = new TreeNode(8);
    root->left->right->left=new TreeNode(6);
    root->left->right->right=new TreeNode(7);
    root->right->right->left=new TreeNode(9);

    cout<<"前序遍历递归版本："<<endl;
    preorder_recursion(root);
    cout<<endl;

    cout<<"前序遍历迭代版本："<<endl;
    preorder_iteration(root);
    cout<<endl;

    cout<<"中序遍历递归版本："<<endl;
    inorder_recursion(root);
    cout<<endl;

    cout<<"中序遍历迭代版本："<<endl;
    inorder_iteration(root);
    cout<<endl;

    cout<<"后序遍历递归版本："<<endl;
    postorder_recursion(root);
    cout<<endl;

    cout<<"后序遍历迭代版本："<<endl;
    postorder_iteration(root);
    cout<<endl;

    //层序遍历
    cout<<"层序遍历版本："<<endl;
    levelorder(root);
    cout<<endl;

    deleteTree(root);

    return 0;
}

输出结果：

前序遍历递归版本：
1 2 4 5 6 7 3 8 9 
前序遍历迭代版本：
1 2 4 5 6 7 3 8 9 
中序遍历递归版本：
4 2 6 5 7 1 3 9 8 
中序遍历迭代版本：
4 2 6 5 7 1 3 9 8 
后序遍历递归版本：
4 6 7 5 2 9 8 3 1 
后序遍历迭代版本：
4 6 7 5 2 9 8 3 1 
层序遍历版本：
1 
2 3 
4 5 8 
6 7 9

原码、补码和反码

Sun, 26 Jan 2025 00:00:00 GMT

1. 前言

在计算机中，数字以二进制的形式存储，分为有符号数和无符号数。顾名思义，有符号数是带符号的，比如正负。无符号数是不带符号的，其范围为：$0\le x\le 2^n-1$。

为了表示一个有符号数，除了数值位以外还应指定符号位，通常以这个数的最高位为符号位，并规定0表示正数的符号“+”；1表示负数的符号“-”。这样，数的符号在机器中也数字化了，符号位和数值位一起完整地表示有符号二进制数。

我们把一个数在机器中的表示形式称为机器数，而把它们的实际数值称为机器数的真值。计算机中，有符号的二进制数可由不同的编码形式表示，它们是原码、补码与反码。下面来详细讨论它们。

2. 原码

原码表示法是一种简单的机器数表示法，即符号和数值表示法。原码就是符号位加上真值的绝对值。以+66和-66为例：

两者的真值均为：1000010，由于以0表示符号为正，以1表示符号为负。因此+66的原码为01000010，-66的原码为11000010。

原码的表示范围为： $$ -(2^{n-1}-1)\le X \le +(2^{n-1}-1) $$ 原码简单易于理解，但是有一个缺点，那就是进行加减运算时很麻烦。参加运算的数可能为正，也可能为负。不仅要考虑运算是加还是减，还要考虑数的绝对值大小。例如，在进行两数相加时，我们要判断：

如果两数同号，数值部分相加，符号不变
如果两数异号，数值部分实际相减，还要对绝对值大小进行判断，才能确定实际的被减数

在原码中，零有两种表示形式：00000000和10000000。

正是存在以上种种弊端，我们才引入补码表示法，能够使正、负数的加法和减法运算简化成单一的相加运算。

3. 反码

正数的反码就是真值本身，负数的反码在原码的基础上，对符号位之外的数按位求反即可。反码的表示范围和原码相同： $$ -(2^{n-1}-1)\le X \le +(2^{n-1}-1) $$ 在反码中，0也有两个编码，反码一般来说很少使用。

4. 补码

正数的原码、反码和补码都是相同的。求补码的步骤如下（以-66为例）：

表示成原码：11000010
求反码：10111101
加1：10111110

补码具有如下性质：

$X$为正数时，补码和原码相同；当$X$为负数时，负数的补码等于$2^n+X=2^n-|X|$
+0和-0的补码是相同的，因此在补码中，0的表示是唯一的。

补码的表示范围为： $$ -2^{n-1}\le X \le 2^{n-1} $$ 补码具有以下运算性质：

加法：$[X+Y]{补}=[X]{补}+[Y]_{补}$
减法：$[X-Y]{补}=[X]{补}-[Y]{补}$，或$[X-Y]{补}=[X]{补}+[-Y]{补}$

5. 参考资料

《微机原理、汇编语言与接口技术》人民邮电出版社

进位计数制及数制之间的互转

Sat, 25 Jan 2025 00:00:00 GMT

1.前言

本文主要介绍进位计数制和数制之间的相互转换。

2. 进位计数制

按照进位的方法进行计数，称为进位计数制。在进位制中每个数规定使用的数码符号的数量，称为进位基数，例如十进制的进位基数是10，二进制的进位基数是2。使用$R$为基数的计数制称为$R$进制数，常用的有十进制数、二进制数、十六进制数和八进制数。

我们习惯把最右边一位称为最低位，最左边一位称为最高位。权值是进位基数从右至左呈指数规律增加，最低位权值位$R^0$，第$i$位的权值为$R^i$。这样就可以把$R$进制中数$N$写成按权展开的多项式： $$ N_R = a_{n-1}R^{n-1} + \cdots + a_iR^i + \cdots + a_0R^0 + a_{-1}R^{-1} + a_{-2}R^{-2} + \cdots + a_{-m}R^{-m} $$

2.1 十进制数(Decimal)

十进制是我们非常熟悉的数制，它的进位基数是10。各位的权值就是我们通常所说的“个”、“十”、“百”、“千”、“万”等。以520.1314为例：

| 数码 | 5 | 2 | 0 | 1 | 3 | 1 | 4 | | :--: | :----: | :----: | :----: | :-------: | :-------: | :-------: | :-------: | | 权值 | $10^2$ | $10^1$ | $10^0$ | $10^{-1}$ | $10^{-2}$ | $10^{-3}$ | $10^{-4}$ | | 总计 | 500 | 20 | 0 | 0.1 | 0.03 | 0.001 | 0.0004 |

2.2 二进制数(Binary)

计算机采用的是“0”和“1”两个基本符号组成的二进制码，因为计算机内部记忆信息的设备由两个状态的器件组成，因而计算机内部的任何信息只能用“0”或“1”这两个状态来表示。17世纪至18世纪的德国数学家莱布尼茨，是世界上第一个提出二进制记数法的人。

二进制的基数为2，逢2进1。以0101.1110为例：

| 数码 | 0 | 1 | 0 | 1 | 1 | 1 | 1 | 0 | | ---- | :-----: | :-----: | :-----: | :-----: | :------: | :------: | :------: | :------: | | 权值 | $2^{3}$ | $2^{2}$ | $2^{1}$ | $2^{0}$ | $2^{-1}$ | $2^{-2}$ | $2^{-3}$ | $2^{-4}$ | | 总计 | 0 | 4 | 0 | 1 | 0.5 | 0.25 | 0.125 | 0 |

所以该数表示的是10进制中的：0+4+0+1+0.5+0.25+0.125+0=5.875

同时，二进制的运算具有如下法则：

加法
- 0 + 0 = 0
- 0 + 1 = 1
- 1 + 0 = 1
- 1 + 1 = 0, 向下一位进1
乘法
- 0×0=0
- 1×0=0
- 0×1=0
- 1×1=1
减法
- 0 - 0=0
- 1 - 0=1
- 1 - 1=0，
- 0 - 1=1，向前一位借1
除法（除数只能为1）
- 0÷1=0
- 1÷1=1

2.3 十六进制(Hexadecimal)

十六进制的基数为16，是一种逢16进1的进位制。通常用数字0、1、2、3、4、5、6、7、8、9和字母A、B、C、D、E、F（a、b、c、d、e、f）表示，其中:A ~ F表示10 ~ 15。以58C.B2为例：

| 数码 | 5 | 8 | C | B | 2 | | :--: | :----: | :----: | :----: | :-------: | :-------: | | 权值 | $16^2$ | $16^1$ | $16^0$ | $16^{-1}$ | $16^{-2}$ | | 总计 | 1280 | 128 | 12 | 0.6875 | 0.0078125 |

所以该数表示的是十进制中的：1280+128+12+0.6875+0.0078125=1420.6953125

2.4 八进制(Octal)

八进制的基数为8，采用0，1，2，3，4，5，6，7八个数字，逢八进1。以520.1为例：

| 数码 | 5 | 2 | 0 | 1 | | :--: | :---: | :---: | :---: | :------: | | 权值 | $8^2$ | $8^1$ | $8^0$ | $8^{-1}$ | | 总计 | 320 | 16 | 0 | 0.125 |

所以该数表示的是10进制中的：320+16+0+0.125=336.125

3. 数制间的转换

其实上面在介绍数制时，我们已经可以窥见它们之间的转换关系，下面进一步明确和总结。

3.1 非十进制数转换为十进制数

这一过程非常简单，由上面的介绍我们可以知道如下的关系式： $$ a_n R^n + a_{n-1} R^{n-1} + \cdots + a_i R^i + \cdots + a_0 = d_m 10^m + d_{m-1} 10^{m-1} + \cdots + d_i 10^i + \cdots + d_1 10 + d_0 $$ 我们只需要将$R^i$和$a^i$用十进制表示，然后作十进制运算即可。这样描述可能比较难以理解，我们举个例子： $$ (1011.101)2 = 1 \times 2^3 + 1 \times 2^1 + 1 \times 2^0 + 1 \times 2^{-1} + 1 \times 2^{-3} = (11.625){10} $$ 其他进制也同理： $$ (3B6){16} = 3 \times 16^2 + 11 \times 16^1 + 6 = 768 + 176 + 6 = (950){10} $$

3.2 十进制数转换为非十进制数

最常用的方法是“除R取余法”：即只需将要被转换的十进制数，连续除以R，直至商等于零为止。第一次除法的余数是$a_0$，而最后一次除法的余数为$a_n$，将$a_n$~$a_1$从高到低排列得$a_n...a_1$，即为所求R进制数。

将$(251)_{10}$转换为二进制数的过程如下：

结果为：$(11111011)_2$

将$(251)_{10}$转换为十六进制数的过程如下：

结果为：$(FB)_{16}$

把十进制小数转换为相应R进制小数时，可以采用“乘R取整法”：即对该小数或乘以基数R后所得的新的小数部分进行乘以基数R的操作，所得整数为R进制的小数位，第一次乘法的余数是$K_{-1}$，而最后一次乘法的余数为$K_{-n}$，将$K_{-1}$~$K_{-n}$，从高到低排列得$K_{-1}…K_{-n}$，即为所求R进制小数。

将$(0.6875)_{10}$转换为二进制数过程如下：

结果为：$(0.1011)_2$

将$(0.6875)_{10}$转换为十六进制数过程如下：

结果为：$(0.BH)_{16}$

并不是所有的小数都能在不同的进制中进行转换，因为不同进制的精度是不一样的，有时候会出现除不尽的情况。

将$(0.734)_{10}$转换为二进制数过程如下：

结果为：$(0.101110)_2$（无穷小数）

综上，如果任意一个十进制数要转换为非十进制数，可以把整数部分和小数部分分别加以转换，然后把转换后的整数部分和小数部分相加即可。

上述的办法不是唯一的转换方法，上述方法非常利于人类进行计算，因为它只涉及除以2，但是这种方法对于机器来说是不理想的。首先这种方法运用的是除法，机器在进行除法运算的时候是非常耗时的；其次机器需要存储计算出的比特，以便稍后以相反的顺序打印。下面以将$(148)_{10}$转换为二进制数为例，说明另一种方法：

首先从小于148的2的最大次幂——128开始比较
148 $\ge$ 128，因此该位为1，148-128=20
20<64，因此该位为0，20
20<32，因此该位为0，20
20 $\ge$ 16，因此该位为1，20-16=4
4<8，因此该位为0，4
4 $\ge$ 4，因此该位为1，4-4=0
0<2，因此该位为0，0
0<1，因此该位为0，0

所以最后的结果为：10010100

如果含有小数部分，也可以仿照该方法进行逐级比较。

这种方法对于人类来说在小数字时（例如 8 位二进制数）相当简单。对于机器来说也很高效，因为每个位只需要需要比较、减法和赋值。

当数字较小，我们手动计算进行转换时，两种方法都可。如果数字较大，我们进行手动计算时选用第一种方法，编写代码时选用第二种方法。

3.3 二进制转换为八进制、十六进制

二进制转换为八进制、十六进制的方法为分组转换。如果转换为八进制，则从左开始，三位一组，不足补零；如果转换为十六进制，则从右开始，四位一组，不足补零。下面以将$(10110110)_2$转换为八进制和十六进制为例。

转换为八进制： $$ (\underline{010}:\underline{110}:\underline{110})_2 $$

$$ (\underline{2}:\underline{6}:\underline{6})_{8} $$
转换为十六进制： $$ (\underline{1011}:\underline{0110})_2 $$

$$ (\underline{B}:\underline{6})_{16} $$

3.4 八进制、十六进制转换为二进制

八进制、十六进制转换为二进制的方法也非常简单。如果是八进制转换为二进制，只需要将八进制的每一位用3位的二进制表示即可；如果是十六进制转换位二进制，只需要将十六进制的每一位用4位的二进制表示即可。

将$(57)_{8}$转换为二进制： $$ (\underline{5}:\underline{7})_8 $$

$$ (\underline{101}:\underline{111})_2 $$

将$(A9)$转换为二进制： $$ (\underline{A}:\underline{9})_{16} $$

$$ (\underline{1011}:\underline{1010})_{2} $$

3.5 八进制和十六进制的相互转换

八进制和十六进制的相互转换可以通过二进制为中介进行转换。非常简单，这里不再举例。

4. 参考资料

《微机原理、汇编语言与接口技术》人民邮电出版社
O.4 — Converting integers between binary and decimal representation – Learn C++

四旋翼无人机基础知识和基本概念

Mon, 13 Jan 2025 00:00:00 GMT

1. 飞行器的分类

飞行器主要分为固定翼、直升机和多旋翼，这里介绍的是多旋翼

2. 四旋翼的总体组成

四旋翼主要组成部分包括机架、动力系统和指挥控制系统。下面进行一一介绍。

2.1 机架

2.1.1 机身

机身一般有如下参数：

重量：选择时尽量轻
布局：常见有四旋翼、六旋翼、八旋翼
轴距：电机轴围成的外界圆周的直径。轴距限制螺旋桨尺寸上限，从而限制了螺旋桨能产生的最大拉力
材料：以碳纤维居多

2.1.2 起落架

具有支撑作用，可以避免起飞离地太近，着陆时可以起缓冲作用

2.1.3 涵道

保护螺旋桨和人身安全，提高桨叶拉力效率和减少噪音（伯努利原理）

2.2 动力系统

2.2.1 螺旋桨

螺旋桨的参数有：

型号
- 假设螺旋桨在一种不能流动的介质中旋转，那么螺旋桨每转一圈,就会向前进一个距离，就称为螺距或桨距(Propeller Pitch)。
- 螺旋桨一般用4个数字表示，其中前面2位是螺旋桨的直径，后面2位是螺旋桨的螺距。比如：1045桨的直径为10英寸，而螺距为4.5英寸。
弦长：一般选择半径2/3处的弦长作为标称弦长
转动惯量
桨叶数
安全转速
螺旋桨力效
静平衡与动平衡
- 静平衡是指螺旋桨重心与轴心线重合时的平衡状态
- 动平衡是指螺旋桨重心与其惯性中心重合时的平衡状态
- 进行静平衡和动平衡的目的是减少振动

2.2.2 电机

电机以无刷电机为主，无刷电机的原理：电机里面一般有多匝线圈，对线圈交替通电可以周而复始驱动转子转动。

电机的参数有：

尺寸：电机的尺寸取决于定子的大小，由一个四位数字来表示。例如2212(或写成22×12)电机，前两个数字代表定子直径(单位mm),后两个数字代表定子高度(单位mm)，因此2212电机表示电机定子直径是22mm，定子高度为12mm。
标称空载KV：空载情况下，外加1V电压得到的转速值，大型螺旋桨可以选用KV值较小的电机，小型螺旋桨可选用KV值较大的电机。
标称空载电流和电压
最大电流/功率
内阻
电机效率
总力效

2.2.3 电调

电调全称电子调速器，英文Electronic Speed Control，简称ESC。最基本的功能是电机调速，同时为遥控接收器其他通道的舵机供电。

电调的参数有：

最大持续/峰值电流：不同电机需要配备不同安数的电调，安数不足会导致电调甚至电机烧毁
电压范围：一般在电调说明书上可以看到标注例如“3-4S LiPo”字样，表示这个电调适用于3到 4节电芯串联的锂聚合物电池，也就是说它的电压范围为11.1V~14.8V
内阻
刷新效率
可编程特性
兼容性

2.2.4 电池

常见的有锂聚合物电池（LiPo）和镍氢电池（NiMh）

电池的参数如下：

电压
- 锂电池组包含两部分：电池和锂电池保护线路。单节电压3.7V。
- 3S1P表示3片锂聚合物电池的串联，电压是11.1V，其中：S是串联，P表示并联。
- 2S2P电池表示2片锂聚合物电池的串联，然后两个这样的串联结构并联，总电压是7.4V，容量是单个电池的两倍。
容量：在实际多旋翼飞行过程中，有两种方式检测电池的剩余容量是否满足飞行安全的要求。一种方式是检测电池单节电压，另一种方式是实时检测电池输出电流做积分计算。
放电倍率
内阻
能量密度

2.3 指挥控制系统

2.3.1 遥控器和接收器

指标参数如下：

频率：常用的无线电频率是72MHz与2.4GHz，目前采用的最多的是2.4GHz遥控器。2.4G微波的直线性很好，尽量避免遥控模型与发射机之间有很大的障碍物（如房屋及仓库等）
调制方式：PCM
通道：一般有六通道、十通道等。多旋翼在控制过程中需要控制的动作路数有：油门、偏航、俯仰、滚转，所以至少得四个通道遥控器。
控制模式：美国手和日本手
油门
- 称直接式油门：油门杆不会自动回中，最低点为0%油门，最高点为100%油门。这种油门主要对应的是期望的推力的大小。
- 增量式油门：松手油门自动回中。
遥控距离

2.3.2 自动驾驶仪

组成：

全球定位系统（GPS）接收器
惯性测量单元（IMU），包括三轴加速度计、三轴陀螺仪、电子罗盘（或磁力计），目的是得到多旋翼的姿态信息
气压计和超声波测距模块
微型计算机
接口

作用：

感知。导航就是解决“多旋翼在哪”的问题
控制。控制就是解决“多旋翼怎么去” 的问题
决策。决策就是解决“多旋翼去哪儿” 的问题

2.3.3 地面站

操作员通过地面站系统提供的鼠标、键盘、按钮和操控手柄等外设来与地面站软件进行交互。预先规划好本次任务的航迹，对多旋翼的飞行过程中飞行状况进行实时监控和修改任务设置以干预多旋翼飞行。任务完成后还可以对任务的执行记录进行回放分析。

2.3.4 数传

数传电台一端接入计算机（地面站软件），一端接入多旋翼自驾仪，通讯采用一定协议进行，从而保持自驾仪与地面站的双向通讯。

数传指标如下：

频率：可选择：433MHz或915MHz
传输距离
传输速率

通信协议：MAVLink通讯协议是一个为微型飞行器设计的非常轻巧的、只由头文件构成的信息编组库。MAVLink最初由劳伦兹·迈耶根据LGPL（Lesser GeneralPublic License）许可在2009年初发表。

3. 四旋翼的坐标系和姿态表示

3.1 坐标系

地球固连坐标系用于研究多旋翼飞行器相对于地面的运动状态，确定机体的空间位置坐标。$x_e$轴水平面指定某一方向，$z_e$轴垂直地面向下，通过右手定则确定$y_e$轴
机体坐标系与多旋翼固连，其原点取在多旋翼的重心位置上。$x_b$轴在多旋翼对称平面内指向机头。$z_b$轴在飞机对称平面内，垂直$x_b$轴向下。然后，按右手定则确定$y_b$轴。

两者关系如下图：

3.2 欧拉角

欧拉角是一种直观的姿态表示方法，在姿态控制中被广泛使用。可以通过绕$\mathbf{e}_3,\mathbf{k}_2,\mathbf{n}_1$轴分别旋转欧拉角$\psi,\theta,\phi$将地球固联坐标系转动到机体坐标系。如图

俯仰角$\theta$：机体轴与地平面（水平面）之间的夹角，飞机抬头为正。
偏航角$\psi$：机体轴在水平面上的投影与地轴之间的夹角，以机头右偏为正。
滚转角$\phi$：飞机对称面绕机体轴转过的角度，右滚为正。

3.3 旋转矩阵

从地球固联坐标系到机体坐标系的旋转可以通过三步来完成

$$ \begin{bmatrix}\mathbf{e}_1\\mathbf{e}_2\\mathbf{e}_3\end{bmatrix} \xrightarrow{\mathbf{R}_z(\psi)} \begin{bmatrix}\mathbf{k}_1\\mathbf{k}_2\\mathbf{k}_3=\mathbf{e}_3\end{bmatrix} \xrightarrow{\mathbf{R}_y(\theta)} \begin{bmatrix}\mathbf{n}_1\\mathbf{n}_2=\mathbf{k}_2\\mathbf{n}_3\end{bmatrix} \xrightarrow{\mathbf{R}_x(\phi)} \begin{bmatrix}\mathbf{b}_1=\mathbf{n}_1\\mathbf{b}_2\\mathbf{b}_3\end{bmatrix} $$

其中 $$\mathbf{R}_z\begin{pmatrix}\psi\end{pmatrix}\triangleq\begin{bmatrix}\cos\psi&\sin\psi&0\-\sin\psi&\cos\psi&0\0&0&1\end{bmatrix},\mathbf{R}_y\begin{pmatrix}\theta\end{pmatrix}\triangleq\begin{bmatrix}\cos\theta&0&-\sin\theta\0&1&0\\sin\theta&0&\cos\theta\end{bmatrix},\mathbf{R}_x\begin{pmatrix}\phi\end{pmatrix}\triangleq\begin{bmatrix}1&0&0\0&\cos\phi&\sin\phi\0&-\sin\phi&\cos\phi\end{bmatrix}$$

因此从机体坐标系到地球固联坐标系的旋转矩阵$\mathbf{R_b^e}$可表示为 $$ \begin{aligned} \mathbf{R_b^{e}}&=\left(\mathbf{R}_\mathrm{e}^\mathrm{b}\right)^{-1}\ &=\mathbf{R}_z^{-1}\left(\psi\right)\mathbf{R}_y^{-1}\left(\theta\right)\mathbf{R}_x^{-1}\left(\phi\right)\ &=\mathbf{R}_z^\mathrm{T}\left(\psi\right)\mathbf{R}_y^\mathrm{T}\left(\theta\right)\mathbf{R}_x^\mathrm{T}\left(\phi\right)\ &=\begin{bmatrix}\cos\theta\cos\psi&\cos\psi\sin\theta\sin\phi-\sin\psi\cos\phi&\cos\psi\sin\theta\cos\phi+\sin\psi\sin\phi\\cos\theta\sin\psi&\sin\psi\sin\theta\sin\phi+\cos\psi\cos\phi&\sin\psi\sin\theta\cos\phi-\cos\psi\sin\phi\-\sin\theta&\sin\phi\cos\theta&\cos\phi\cos\theta\end{bmatrix}&\mathrm{I} \end{aligned} $$

当然知道了旋转矩阵我们也可以反过来求欧拉角。

3.4 四元数

四元数是目前应用最广泛的姿态表示方法之一，四元数本质上是一种高阶复数，是一个四维空间，一般表示为： $$ \mathbf{q} \triangleq\left[\begin{array}{l}q_0 \ \mathbf{q}_{\mathrm{v}}\end{array}\right] $$ 其中$q_0$表示标量部分，$\mathbf{q_v}$表示向量部分。

四元数有如下基本运算法则：

加减法 $$ \mathbf{p} \pm \mathbf{q}=\left[\begin{array}{l} p_0 \ \mathbf{p}{\mathrm{v}} \end{array}\right] \pm\left[\begin{array}{l} q_0 \ \mathbf{q}{\mathrm{v}} \end{array}\right]=\left[\begin{array}{l} p_0 \pm q_0 \ \mathbf{p}{\mathrm{v}} \pm \mathbf{q}{\mathrm{v}} \end{array}\right] $$
乘法 $$ \mathbf{p} \otimes \mathbf{q}=\left[\begin{array}{l} p_0 \ \mathbf{p}{\mathrm{v}} \end{array}\right] \otimes\left[\begin{array}{l} q_0 \ \mathbf{q}{\mathrm{v}} \end{array}\right]=\left[\begin{array}{c} p_0 q_0-\mathbf{q}{\mathrm{v}}^{\mathrm{T}} \mathbf{p}{\mathrm{v}} \ \mathbf{p}{\mathrm{v}} \times \mathbf{q}{\mathrm{v}}+p_0 \mathbf{q}{\mathrm{v}}+q_0 \mathbf{p}{\mathrm{v}} \end{array}\right] $$ 乘法不满足交换律，但是满足分配率和结合律。
共轭 $$ \mathbf{q}^*=\left[\begin{array}{c} q_0 \ -\mathbf{q}_{\mathbf{v}} \end{array}\right] $$
范数 $$ \begin{aligned} |\mathbf{q}|^2 & =\left|\mathbf{q} \otimes \mathbf{q}^\right| \ & =\left|\mathbf{q}^ \otimes \mathbf{q}\right| \ & =q_0^2+\mathbf{q}{\mathbf{v}}^{\mathrm{T}} \mathbf{q}{\mathbf{v}} \ & =q_0^2+q_1^2+q_2^2+q_3^2 . \end{aligned} $$
求逆

四元数的逆$\mathbf{q^{-1}}$ $$ \mathbf{q} \otimes \mathbf{q}^{-1}=\left[\begin{array}{c} 1 \ \mathbf{0}_{3 \times 1} \end{array}\right] $$
除法

如果$\mathbf{r}\otimes \mathbf{p}=\mathbf{m}$，则有 $$ \begin{aligned} \mathbf{r} \otimes \mathbf{p} \otimes \mathbf{p}^{-1} & =\mathbf{m} \otimes \mathbf{p}^{-1} \ \mathbf{r} & =\mathbf{m} \otimes \mathbf{p}^{-1} \end{aligned} $$

我们可以使用四元数来表示旋转

向量旋转 $$ \left[\begin{array}{c} 0 \ \mathbf{v}_1^{\prime} \end{array}\right]=\mathbf{q} \otimes\left[\begin{array}{l} 0 \ \mathbf{v}_1 \end{array}\right] \otimes \mathbf{q}^{-1} $$
坐标系旋转 $$ \left[\begin{array}{c} 0 \ \mathbf{v}_1^{\prime} \end{array}\right]=\mathbf{q}^{-1} \otimes\left[\begin{array}{c} 0 \ \mathbf{v}_1 \end{array}\right] \otimes \mathbf{q} $$

关于四元数更多内容可参考：https://krasjet.github.io/quaternion/

4. 四旋翼的运动

悬停：转速相同，1和3逆时针旋转，2和4顺时针旋转，俯仰力矩和翻滚力矩相互抵消，拉力抵消重力
上下运动：同时改变四个螺旋桨转速，力矩和仍然为0，但是总拉力会变化
前后运动：减小1和4转速，拉力会产生向前分量，同时拉力垂直分量会减小，需要同量增加四个螺旋桨转速来补偿向后运动同理
左右运动：同量减小1和2的转速，同量增加3和4的转速，会产生向右翻滚倾斜的力矩，拉力会产生向右分量，同时拉力垂直分量会减小，需要同量增加四个螺旋桨转速来补偿，向左运动同理
偏航运动：同量减小2和4的转速，同量增加1和3的转速，会产生一个顺时针的偏航力矩

参考资料：

电子工业出版社《多旋翼飞行器设计与控制》

D435i 配置教程

Sun, 12 Jan 2025 00:00:00 GMT

1. 前言

Intel RealSense D435i是英特尔公司推出的一款消费级深度相机。它主要包含一个RGB相机、两个红外相机以及一个红外发射器，此外还有一个IMU单元(这也就是D435i和D435的区别，i就表示imu)。本教程的SDK版本为v2.50.0，对应的固件版本为v5.13.0.50，需要使用3.0及3.0以上数据线和数据接口，不然会报错。

2. 驱动安装

2.1 驱动安装

摄像头官方文档：https://dev.intelrealsense.com/docs/docs-get-started

驱动仓库：https://github.com/IntelRealSense/librealsense

克隆驱动仓库（指定版本，踩过坑，驱动版本需要和固件相对应）
```
git clone -b v2.50.0 https://github.com/IntelRealSense/librealsense  
```

克隆可能会发生错误，可以直接在该页面下载压缩包：https://github.com/IntelRealSense/librealsense/tree/v2.50.0

安装依赖

sudo apt-get install libudev-dev pkg-config libgtk-3-dev
sudo apt-get install libusb-1.0-0-dev pkg-config
sudo apt-get install libglfw3-dev
sudo apt-get install libssl-dev

安装权限脚本(进入librealsense-2.50.0文件夹执行以下命令)

sudo cp config/99-realsense-libusb.rules /etc/udev/rules.d/
sudo udevadm control --reload-rules && udevadm trigger

编译和安装

mkdir build
cd build
cmake ../ -DBUILD_EXAMPLES=true
make
sudo make install

如果编译过慢可以使用make -j8命令

测试安装
```
realsense-viewer
modinfo uvcvideo | gr
```
插入摄像头屏幕可能发生翻转：重启即可

注意： USB线必须使用3.0以上的，同时如果在虚拟机中需要将USB兼容性改为3.1，参考链接：https://blog.csdn.net/qq_28872655/article/details/131452813

显示如图界面则成功

2.2 ROS接口安装

创建ROS工作区

mkdir -p ~/realsense_ros_ws/src
cd ~/realsense_ros_ws/src

克隆仓库

git clone https://github.com/IntelRealSense/realsense-ros.git
git clone https://github.com/pal-robotics/ddynamic_reconfigure.git

列出仓库中的所有标签，切换到2.x.x的最新版本

cd realsense-ros/
git checkout `git tag | sort -V | grep -P "^2.\d+\.\d+" | tail -1`

初始化ROS工作区

cd ../../
cd ~/realsense_ros_ws/src
catkin_init_workspace

进行编译

cd ..
catkin_make clean
catkin_make -DCATKIN_ENABLE_TESTING=False -DCMAKE_BUILD_TYPE=Release
catkin_make install

设置环境变量

echo "source ~/realsense_ros_ws/devel/setup.bash" >> ~/.bashrc
source ~/.bashrc

启动摄像头节点
```
roslaunch realsense2_camera rs_camera.launch
```
此时可以用rostopic来查看相关话题

3. 参考链接

Windows 的 PowerShell 美化教程

Sat, 23 Nov 2024 00:00:00 GMT

1. 前言

记录在一次Windows中升级PowerShell 5.1至PowerShell 7的，并使用 oh my posh 对终端进行美化的折腾过程。

2. 升级PowerShell

参考在 Windows 上安装 PowerShell - PowerShell | Microsoft Learn，在PowerShell中直接运行如下命令安装最新版本

winget install --id Microsoft.Powershell --source winget

安装完成后需要修改默认终端，随便打开一个终端，点击设置，然后将默认启动改为PowerShell 7，如图：

3. 使用 oh my posh 进行美化

在PowerShell中进行安装：

Set-ExecutionPolicy Bypass -Scope Process -Force; Invoke-Expression ((New-Object System.Net.WebClient).DownloadString('https://ohmyposh.dev/install.ps1'))

重启终端，输入oh-my-posh，若打印如下内容，则说明安装成功：

更改PowerShell的安全策略：以管理员身份运行，然后输入如下内容：

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope LocalMachine

打开配置文件

notepad $PROFILE

如果提示该文件不存在，可以使用如下命令创建

New-Item -Path $PROFILE -Type File -Force

在打开的配置文件添加以下代码并保存

oh-my-posh init pwsh | Invoke-Expression

重新打开终端会加载默认主题。

在Nerd Fonts 官网下载一款自己喜欢的字体，这里以Cousine Nerd Font为例，解压压缩包后，右键安装所有字体

然后在外观中配置刚刚下载的字体，如图

显示可用的主题：

Get-PoshThemes

记住好自己要切换的主题名称，然后ctrl+左键打开主题文件夹，如图

打开配置文件：

notepad $PROFILE

配置主题路径，以wholespace主题为例：

oh-my-posh init pwsh  --config "Senv:POSH_THEMES_PATH/wholespace.omp.json" | Invoke-Expression

重载主题，命令如下

. $PROFILE

当然，还可以在终端外观设置中设置背景和透明度。

4. Vsocde中的乱码配置

使用的时候发现在VScode中会乱码，安装下面步骤更改终端字体即可：

打开设置
搜索Integrated:Font Family
将字体修改为上面设置的字体

5. 参考资料

https://mp.weixin.qq.com/s/KWlN5s_rdLn8oO_iL2vbgg

Git 中对提交历史进行处理

Fri, 15 Nov 2024 00:00:00 GMT

1. 前言

在之前的Git 的使用总结这篇博客中，总结了一些Git的基础命令和用法，这篇博客将对Git中的版本管理操作作进一步总结。

2. 场景

我们使用Git来管理我们的项目时，有时候会不小心提交一些不该提交的文件，如果我们直接将这些文件删除，会留下提交记录。所以我们需要删除那次的提交记录，主要的方法有git reset和git rebase

3. 操作流程

3.1 使用git reset 命令

先查看提交历史

git log --oneline

确认需要删除的提交的位置，假设提交历史如下

abc1234 Third commit (最新提交)
def5678 Second commit (需要删除的提交)
ghi9101 First commit

将指针重置到First commit，并将更改保留在暂存区。可以使用如下命令
```
git reset --soft HEAD~3
```
或使用
```
git reset --soft ghi9101
```
从暂存区删除我们错误提交的文件，然后重新commit
然后执行以下命令推送到远程仓库
```
git push origin main --force
```
之所以要使用--force，是因为通常Git 在推送时会检查你本地的提交历史是否与远程仓库的历史一致。如果本地和远程仓库的提交历史有冲突（例如你使用 git rebase 或 git reset 修改了本地历史），Git 默认会拒绝推送，以防止你覆盖远程仓库中的提交历史。当你想要覆盖远程仓库的历史时（例如修改或删除提交），必须使用 --force 选项，告诉 Git 你明确地希望覆盖远程历史。
完成

3.2 使用git rebase 命令

先查看提交历史

git log --oneline

确认需要删除的提交的位置，假设提交历史如下

abc1234 Third commit (最新提交)
def5678 Second commit (需要删除的提交)
ghi9101 First commit

打开一个编辑器，并显示最近 3 个提交的列表
```
git rebase -i HEAD~3
```
在编辑器中找到需要删除的提交，将其对应的 pick 改成 drop，如下所示：
```
pick abc1234 Third commit
drop def5678 Second commit
pick ghi9101 First commit
```
完成 Rebase 后强制推送更改：
```
git push origin main --force
```
完成

4. git reset 和 git rebase 的不同

git reset 和 git rebase 是 Git 中两个常用的命令，它们都可以改变历史记录，但它们的用途和效果有所不同。下面是它们的主要区别和使用场景：

4.1. git reset

git reset 主要用于重置当前分支的 HEAD（当前提交的指针），它可以用于修改 Git 提交历史的指针位置，并根据不同的模式（如 --soft、--mixed、--hard）决定如何处理工作区和暂存区的内容。

常用选项：

git reset --soft <commit>：将 HEAD 移动到指定的提交位置，并将所有更改保留在暂存区（staging area），即重新准备提交这些更改。
git reset --mixed <commit>：将 HEAD 移动到指定的提交位置，并将更改保留在工作区，但从暂存区移除这些更改（相当于 git rm --cached）。
git reset --hard <commit>：将 HEAD 和工作区都移动到指定提交的位置，丢弃所有更改。所有的修改（无论是暂存区还是工作区的）都会丢失。

使用场景：

撤销提交：你可以用 git reset 撤销最近的提交（git reset --soft HEAD~1 或 git reset --mixed HEAD~1），并选择保留更改在工作区或暂存区。
撤销修改：通过 git reset --hard 可以彻底丢弃所有本地修改（包括工作区和暂存区），回到某个提交的状态。
调整历史记录指针：它通常用于调整 HEAD 指针的位置，可以方便地回到之前的某个提交。

示例：

# 撤销最后一次提交并将更改保留在暂存区
git reset --soft HEAD~1

# 撤销最后一次提交并将更改保留在工作区
git reset --mixed HEAD~1

# 完全撤销最后一次提交并丢弃所有更改
git reset --hard HEAD~1

4.2. git rebase

git rebase 是一个更为强大的命令，用于将一系列提交“重放”到另一分支上。git rebase 会修改分支的历史记录，它会“将你的提交移到另一个分支的后面”，就像你从一个新的基础上开始工作一样。

常用选项：

git rebase <branch>：将当前分支的所有提交“重放”到 <branch> 分支的末尾。例如，git rebase main 将当前分支的提交应用到 main 分支的末尾。
git rebase -i <commit>：交互式 rebase，用于编辑提交历史、删除、合并、修改提交信息等。你可以选择哪些提交进行修改。

使用场景：

清理历史提交：git rebase -i 允许你对提交进行重写、合并、修改提交信息等，非常适合清理提交历史。
合并提交：通过 git rebase 将多个提交合并成一个提交（squash），让历史更加整洁。
保持历史线性：使用 git rebase 来避免合并提交（merge commits），让提交历史更干净。

示例：

# 将当前分支的提交重放到 main 分支上
git rebase main

# 交互式 rebase，用于修改提交历史
git rebase -i HEAD~3

Obsidian 复刻 Typora 的图片操作

Thu, 14 Nov 2024 00:00:00 GMT

1. 前言

最近入坑了Obsidian🤗🤗🤗，由于学习成本太高，之前一直没有入坑，因为Typora真的挺好的。但是由于Obsidian可自定义程度非常高，所以还是决定从Typora迁移到Obsidian。这篇博客主要记录一些图片相关的问题，例如：图片的自动居中，图片的缩放，图床的设置，如何利用脚本工具将图片从Markdown自动转换成HTML语法。

2. 图片的自动居中

正常来说直接插入Markdown的图片是占满整个页宽的，所以居中不居中看不出来，但是如果对图片进行缩放时，图片会自动靠左，其实这主要取决于Markdown编辑器，例如在vscode中图片就是自动居中的，要在Typora中实现图片自动居中，可以通过添加CSS来实现，具体步骤如下：

在设置界面，点击外观，然后打开CSS文件夹

在该文件夹下，新建一个center.css，复制粘贴以下内容：

img {
    display: block !important;
    margin-left: auto !important;
    margin-right: auto !important;
}

 .markdown-source-view.mod-cm6 .cm-content > * {
    margin: auto auto !important;
}

回到刚才的页面，开启该代码片段，如图

3. 图片的缩放

如果是Markdown语法的缩放，可以使用插件 mousewheel-image-zoom ，但是这个语法不是Markdown的通用语法，一般在Markdown中图片的缩放是使用HTML语法的，例如：

<img src="https://raw.githubusercontent.com/liangbm3/photos/main/Typora/20241113224150.png" style="zoom:67%;">

这个语句可以实现图片缩放67%，所以只要我们只要将图片写成HTML的表达方式，就可以很方便地缩放了。

4. 图床的设置

为什么要设置图床？一方面当然是方便Markdown文件的传播，还有一个重要的原因是Obsidian图片的HTML语法不支持相对路径（🙃🙃🙃），我们写Markdown一般不会写绝对路径，使用图床我们可以得到的是一个链接，这是一个非常完美的解决方案。关于图床，网上有很多种，这里以Github+PicGo-Core为例：

安装了 node 或 yarn 之后，在终端中以下命令
```
npm install picgo -g

# or

yarn global add picgo
```

进行配置

picgo 的默认配置文件为~/.picgo/config.json。其中~为用户目录。不同系统的用户目录不太一样。

Linux 和 macOS 均为~/.picgo/config.json。

windows 则为C:\Users\你的用户名\.picgo\config.json

一个示例如下图：

{
  "picBed": {
    "uploader": "github",
    "current": "github",
    "github": {
      "repo": "",
      "branch": "",
      "token": "",
      "path": "",
      "customUrl": ""
    },
    "transformer": "path"
  },
  "picgoPlugins": {}
}

注释如下：

{
  "repo": "", // 仓库名，格式是 username/reponame
  "token": "", // github token
  "path": "", // 自定义存储路径，比如 img/
  "customUrl": "", // 自定义域名，注意要加 http://或者 https://
  "branch": "" // 分支名，默认是 main
}

Github 获取个人 token
- 访问：settings-tokens ，点击Generate new token
- 设置 token 属性
  - Expiration：no expiration
  - Select scopes：repo 选择存放的仓库
  - 点击Generate token，生成 token。
这个 token 生成后只会显示这一次！注意复制、保存到其他地方以备后续使用。
将信息填入上述json文件即可

也可以通过在终端输入picgo set uploader按照提示自动生成json文件
配置好picgo后进入Obsidian中下载插件 Image auto upload Plugin
可以设置粘贴自动上传图片，如图

到这里图床已经完成了。

5. Markdown自动转换成HTML语法

这个是Typora中的一个特色功能，如图

然而似乎Obsidian中没有类似的插件实现这个功能。

在Windows中，我们可以借助自动化工具 AutoHotkey 实现，步骤如下：

进入AutoHotkey 官网，下载安装包，安装。
在合适的位置，右键，新建一个.ahk脚本

用文本编辑器打开，复制粘贴如下内容

^p:: ; 按下 Ctrl + P 触发
    Clipboard := "" ; 清空剪贴板
    Send ^c ; 复制当前选中内容
    ClipWait, 1 ; 等待内容进入剪贴板

    ; 检查是否是 Markdown 图片格式并替换为 HTML 图片标签
    if (Clipboard ~= "!\[.*?\]\((.*?)\)") {
        ; 使用正则表达式将 Markdown 图片语法转换为 HTML <img> 标签
        newContent := RegExReplace(Clipboard, "!\[.*?\]\((.*?)\)", "<img src=""" . "$1" . """ style=""zoom:67%;"">")
        
        ; 将新内容设置为剪贴板内容
        Clipboard := newContent
        ClipWait, 1 ; 等待剪贴板更新
        Send ^v ; 粘贴替换后的内容
    }
return

保存退出，然后我们双击运行该脚本，运行之后可以在系统托盘中看到一个H图标
之后我们只要在Obsidian里面选中要转换的Markdown图片语法，按住Ctrl + P，即可自动转换，非常方便。

6. 参考链接

使用 scp 在计算机和远程服务器直接传输文件

Tue, 05 Nov 2024 00:00:00 GMT

1. 简介

SCP（Secure Copy Protocol）是一种用于在计算机之间安全传输文件的协议，通常用于在本地计算机和远程服务器之间复制文件。

2. 使用说明

语法：

scp [可选参数] file_source file_target

可选参数如下：

-1：强制scp命令使用协议ssh1
-2：强制scp命令使用协议ssh2
-4：强制scp命令只使用IPv4寻址
-6：强制scp命令只使用IPv6寻址
-C：允许压缩。（将-C标志传递给ssh，从而打开压缩功能）
-p：保留原文件的修改时间，访问时间和访问权限。
-q：不显示传输进度条。
-r：递归复制整个目录。
-l limit：限定用户所能使用的带宽，以Kbit/s为单位。
-P port：注意是大写的P, port是指定数据传输用到的端口号

3. 使用示例

将本地一个文件复制到远程服务器的桌面
```
scp file.zip root@192.168.2.1:/home/Desktop
```
将本地一个文件夹复制到远程服务器的桌面
```
scp -r file root@192.168.2.1:/home/Desktop
```

指定端口进行复制

scp -r 端口号 file root@192.168.2.1:/home/Desktop

从服务器中下载

scp root@192.168.2.1:/home/Desktop/file.zip "D:\Downloads\Compressed"

4. 参考资料

Linux scp命令 | 菜鸟教程

Python 多线程、多进程和协程

Mon, 04 Nov 2024 00:00:00 GMT

1. 前言

在Python中，多线程、多进程和协程是处理并发任务的三种常用方式。它们各有优缺点，适合不同的场景。

2. python多线程

使用threading模块，threading模块通过共享内存来实现多线程，所有线程共享一样的变量，适用于I/O密集型任务。

2.1. 一个线程的完整周期

新建：新建一个线程对象
就绪：调用start方法后，线程对象等待运行，什么时候开始取决于调度
运行：线程处于运行状态
阻塞：处于运行状态的线程被阻塞
死亡：线程执行完毕或异常退出，线程对象销毁并释放内存

2.2. 一些使用实例

直接使用Thread创建线程对象

from threading import Thread

def print_numbers(range_start, range_end):
    for i in range(range_start, range_end):
        print(i)
        
t1 = Thread(target=print_numbers, args=(1, 10))
t2 = Thread(target=print_numbers, args=(11, 20))

t1.start()
t2.start()

t1.join()
t2.join()

重写父类threading.Thread创建线程

import threading 

#继承Thread并重写
class myThread(threading.Thread):
    #重写构造函数
    def __init__(self,start_num,end_num):
        threading.Thread.__init__(self)
        self.start_num = start_num
        self.end_num = end_num
    #重写run函数
    def run(self):
        print(f"线程开始{self.name}")
        for i in range(self.start_num,self.end_num):
            print(i)
        print(f"线程结束{self.name}")
        
thread1 = myThread(1,10)
thread2 = myThread(11,20)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

3. python多进程

使用multiprocessing模块，用法和threading类似。一些使用实例如下：

直接使用Process创建进程对象

import multiprocessing

def print_numbers(range_start, range_end):
    for i in range(range_start, range_end):
        print(i)

if __name__ == '__main__':      
    p1 = multiprocessing.Process(target=print_numbers, args=(1, 100))
    p2 = multiprocessing.Process(target=print_numbers, args=(110, 200))

    p1.start()
    p2.start()
    p1.join()
    p2.join()

重写父类multiprocessing.Process

import multiprocessing

#继承Thread类并重写
class myProcess(multiprocessing.Process):
    #重写构造函数
    def __init__(self,start_num,end_num):
        multiprocessing.Process.__init__(self)
        self.start_num = start_num
        self.end_num = end_num
    #重写run函数
    def run(self):
        print(f"进程开始{self.name}")
        for i in range(self.start_num,self.end_num):
            print(i)
        print(f"进程结束{self.name}")
if __name__ == '__main__':
    process1 = myProcess(1,100)
    process2 = myProcess(110,200)
    
    process1.start()
    process2.start()
    
    process1.join()
    process2.join()

3. python线程池和进程池

系统启动一个新线程的成本是比较高的，因为它涉及与操作系统的交互。在这种情形下，使用线程池可以很好地提升性能，尤其是当程序中需要创建大量生存期很短暂的线程时，更应该考虑使用线程池。

线程池在系统启动时即创建大量空闲的线程，程序只要将一个函数提交给线程池，线程池就会启动一个空闲的线程来执行它。当该函数执行结束后，该线程并不会死亡，而是再次返回到线程池中变成空闲状态，等待执行下一个函数。

此外，使用线程池可以有效地控制系统中并发线程的数量。当系统中包含有大量的并发线程时，会导致系统性能急剧下降，甚至导致Python 解释器崩溃，而线程池的最大线程数参数可以控制系统中并发线程的数量不超过此数。

使用实例：

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def spider(page):
    time.sleep(page)
    print(f"crawl task{page} finished")
    return page

if __name__ == '__main__':
    with ThreadPoolExecutor(max_workers=5) as t:
        obj_list = []
        for page in range(1, 5):
            obj = t.submit(spider, page)
            obj_list.append(obj)

        for future in as_completed(obj_list):
            data = future.result()
            print(f"main: {data}")

程序将 task 函数提交（submit）给线程池后，submit 方法会返回一个 Future 对象，Future 类主要用于获取线程任务函数的返回值。由于线程任务会在新线程中以异步方式执行，因此，线程执行的函数相当于一个“将来完成”的任务，所以 Python 使用 Future 来代表。

4. 协程

协程（Coroutines）是一种特殊的软件构造，它允许程序在执行过程中暂停并恢复执行，而不会丢失当前的执行上下文。与线程和进程不同，协程在单个线程中运行，通过调度机制实现并发，降低了上下文切换的开销，提高了程序的执行效率。协程通常用于处理I/O密集型任务，如网络请求、文件读写等。

使用asyncio库来实现协程示例：

import asyncio

async def task(num):
    print(f"Task {num} started")
    await asyncio.sleep(1)
    print(f"Task {num} completed")

async def main():
    tasks = [task(i) for i in range(3)]  # 创建多个任务
    await asyncio.gather(*tasks)  # 并行运行所有任务，并等待它们完成

if __name__ == "__main__":
    asyncio.run(main())  # 运行主函数

ROS1 基础与常用命令

Sun, 03 Nov 2024 00:00:00 GMT

1. 前言

接触ROS差不多有一年多了，最近由于科研的需要，又重新捡了起来。个人觉得快速上手ROS的方法是在理解大概原理的前提下，快速把常用的操作过一遍。在使用ROS的时候，有时一些命令常常想不起来，上网查阅又需要花费大量时间，这里一并总结了一下。

2. ROS的安装

一般的使用场景都是在Ubuntu 20.04 上安装Noetic版本，一般在有代理的情况下，按照官方的教程，可以一次性安装成功，步骤如下：

设置源列表使计算机接受来自packages.ros.org的软件

sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'

设置Key

sudo apt install curl # 安装curl，若已安装则跳过

curl -s https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc | sudo apt-key add -

安装

sudo apt update #更新软件包索引
sudo apt install ros-noetic-desktop-full #安装完整版

设置环境变量

echo "source /opt/ros/noetic/setup.bash" >> ~/.bashrc
source ~/.bashrc

安装常用的构建依赖项

sudo apt install python3-rosdep python3-rosinstall python3-rosinstall-generator python3-wstool build-essential

安装和初始化rosdep

sudo apt install python3-rosdep
sudo rosdep init
rosdep update

安装完成后，后续如果要安装其他软件包，可以在ROS Packages中寻找，或者使用命令：

apt search ros-noetic

若想安装特定的软件包，可以使用命令：

sudo apt install ros-noetic-PACKAGE

3. ROS简介

ROS（Robot Operating System）是一个用于机器人开发的开源框架，旨在简化机器人软件的开发。它提供了一系列工具、库和约定，以便于开发者创建复杂的机器人应用。

节点（Node）

节点是ROS系统中的基本计算单元。每个节点都是一个独立的进程，可以执行特定的任务。不同的节点可以用不同的语言编写。
话题（Topic）

话题是ROS中节点之间通信的方式。节点可以发布（publish）和订阅（subscribe）话题。发布者将消息发送到特定的话题，而订阅者接收该话题的消息。这样，节点之间的耦合度降低，增加了系统的灵活性。
服务（Service）

服务是ROS中另一种通信机制，允许节点通过请求-响应模式进行交互。一个节点提供服务，另一个节点调用该服务。
消息（Message）

消息是ROS中传递的数据结构。每种类型的消息都有其特定的格式，定义了节点之间交换的数据。ROS内置了多种基本消息类型，也支持用户自定义消息类型。
参数服务器（Parameter Server）

参数服务器是一个共享的全局数据库，用于存储配置参数。节点可以读取和写入这些参数，以便动态调整系统的行为。
工作空间（Workspace）

工作空间是ROS开发环境的一个目录，包含了ROS包、库和配置文件。我们可以在工作空间中编写、测试和管理机器人应用。
包（Package）

ROS的功能以包的形式组织。每个包可以包含节点、库、配置文件、文档等。包的结构使得代码的复用和共享变得更加方便。

4. 构建工作区

我们这里以在home目录中创建一个名为catkin_ws的工作区为例

mkdir -p catkin_ws/src
cd catkin_ws
catkin_make
catkin_make install #添加install文件夹

这里有一个坑：如果之前在Ubuntu中安装了Anaconda或者miniconda，会出现找不到empy包的错误。

解决方案：
设置启动终端时不自动进入base环境，命令：
conda config --set auto_activate_base false
重新打开终端，重新编译：
rm -rf build devel
catkin_make

在每次运行软件包时，我们通常要先设置环境变量，为了避免频繁操作，可以将其写入.bashrc文件中，这样每次启动终端时会自动设置。

使用命令

echo "source ~/catkin_ws/devel/setup.bash" >> ~/.bashrc
source ~/.bashrc

检查环境变量：

echo $ROS_PACKAGE_PATH

5. 基础操作例程

5.1 小海龟

小海龟例程是ROS非常经典的入门学习包，可以让我们快速熟悉ROS命令行工具的使用

启动ROS Master
```
roscore
```
启动小海龟仿真器节点
```
rosrun turtlesim turtlesim_node
```
启动海龟控制节点
```
rosrun turtlesim turtle_teleop_key
```
启动上述两个节点之后，我们便可以用键盘来控制海龟的移动。
查看系统计算图
```
rqt_graph
```
从图中可知，目前ROS系统中存在两个节点，一个是海龟仿真器节点turtlesim，其订阅了话题/turtle1/cmd_vel，还有一个节点是teleop_turtle，其往/turtle1/cmd_vel中发布信息，这样两个节点间便完成了通讯。

节点相关信息的命令为rosnode，示例：

查看节点列表

rosnode list

输出：

/rosout
/rqt_gui_py_node_83022
/teleop_turtle
/turtlesim

查看某个节点的信息

rosnode info /turtlesim

输出：

Node [/turtlesim]
Publications: 
 * /rosout [rosgraph_msgs/Log]
 * /turtle1/color_sensor [turtlesim/Color]
 * /turtle1/pose [turtlesim/Pose]

Subscriptions: 
 * /turtle1/cmd_vel [geometry_msgs/Twist]

Services: 
 * /clear
 * /kill
 * /reset
 * /spawn
 * /turtle1/set_pen
 * /turtle1/teleport_absolute
 * /turtle1/teleport_relative
 * /turtlesim/get_loggers
 * /turtlesim/set_logger_level


contacting node http://ubuntu:37017/ ...
Pid: 82069
Connections:
 * topic: /rosout
    * to: /rosout
    * direction: outbound (52857 - 127.0.0.1:47492) [26]
    * transport: TCPROS
 * topic: /turtle1/cmd_vel
    * to: /teleop_turtle (http://ubuntu:41229/)
    * direction: inbound (45856 - ubuntu:38849) [32]
    * transport: TCPROS

话题相关命令为rostopic，示例：

查看话题列表：

rostopic list

输出：

/rosout
/rosout_agg
/statistics
/turtle1/cmd_vel
/turtle1/color_sensor
/turtle1/pose

发布话题:

rostopic pub /turtle1/cmd_vel geometry_msgs/Twist "linear:
  x: 1.0
  y: 1.0
  z: 0.0
angular:
  x: 1.0
  y: 0.0
  z: 0.0"

消息相关命令为rosmsg，示例：

查看消息类型

rosmsg show geometry_msgs/Twist

输出：

geometry_msgs/Vector3 linear
  float64 x
  float64 y
  float64 z
geometry_msgs/Vector3 angular
  float64 x
  float64 y
  float64 z

服务相关命令为rosservice，示例：

查看提供服务的内容

rosservice list

输出：

/clear
/kill
/reset
/rosout/get_loggers
/rosout/set_logger_level
/rqt_gui_py_node_84673/get_loggers
/rqt_gui_py_node_84673/set_logger_level
/spawn
/teleop_turtle/get_loggers
/teleop_turtle/set_logger_level
/turtle1/set_pen
/turtle1/teleport_absolute
/turtle1/teleport_relative
/turtlesim/get_loggers
/turtlesim/set_logger_level

请求产生一个海龟的服务
```
rosservice call /spawn "x: 0.0
y: 0.0
theta: 0.0
name: 'turtle2'" 
```
执行完后会在turtlesim中产生一个海龟

话题记录和复现工具

话题记录
```
rosbag record -a -O cmd_record
```
话题复现
```
rosbag play cmd_record.bag
```

5.2 发布和订阅

发布和订阅是ROS最基础的通信机制，这里演示如何创建功能包，编写一个信息发布节点 Publisher，和一个信息订阅节点 Pubscriber。

5.2.1 功能包的构建和编译

创建功能包

catkin_create_pkg <package_name> [depend1] [depend2] [depend3]

示例：

执行命令创建功能包

cd ~/catkin_ws/src/
catkin_create_pkg pub_sub_pkg std_msgs rospy roscpp

编译功能包

cd ~/catkin_ws/
catkin_make
source /devel/setup.bash

5.2.2 Publisher的编写

5.2.2.1 cpp版本的实现

在pub_sub_pkg/src/路径下新建文件random_number_publisher.cpp，添加如下内容

#include <ros/ros.h>
#include <std_msgs/Int32.h>
#include <cstdlib>  // for rand()
#include <ctime>    // for time()

int main(int argc, char** argv) {
    ros::init(argc, argv, "random_number_publisher");
    ros::NodeHandle nh;

    // 创建一个发布者，发布到 "random_number" 主题
    ros::Publisher random_pub = nh.advertise<std_msgs::Int32>("random_number", 10);

    // 初始化随机数生成器
    std::srand(static_cast<unsigned int>(std::time(0)));

    // 设置循环频率
    ros::Rate loop_rate(1);  // 每秒发布一次

    while (ros::ok()) {
        // 创建一个消息并设置随机数
        std_msgs::Int32 msg;
        msg.data = std::rand() % 100;  // 生成 0 到 99 的随机数

        // 发布消息
        random_pub.publish(msg);
        ROS_INFO("Published random number: %d", msg.data);

        // 休眠直到下一个循环
        ros::spinOnce();
        loop_rate.sleep();
    }

    return 0;
}

修改 CMakeLists.txt

添加如下内容：

add_executable(random_number_publisher src/random_number_publisher.cpp)
target_link_libraries(random_number_publisher ${catkin_LIBRARIES})

编译包

回到工作空间，输入catkin_make编译包

5.2.2.2 py版本的实现

在 pub_sub_pkg/src 目录下创建一个名为 random_number_publisher.py 的文件，并添加如下内容

import rospy
from std_msgs.msg import Int32
import random

def random_number_publisher():
    # 初始化节点
    rospy.init_node('random_number_publisher', anonymous=True)
    # 创建一个发布者，发布到 "random_number" 主题
    pub = rospy.Publisher('random_number', Int32, queue_size=10)
    # 设置循环频率
    rate = rospy.Rate(1)  # 每秒发布一次

    while not rospy.is_shutdown():
        # 生成随机数
        random_number = random.randint(0, 99)  # 生成 0 到 99 的随机数
        rospy.loginfo("Published random number: %d", random_number)
        # 创建消息并发布
        pub.publish(random_number)
        # 休眠直到下一个循环
        rate.sleep()

if __name__ == '__main__':
    try:
        random_number_publisher()
    except rospy.ROSInterruptException:
        pass

修改 CMakeLists.txt

添加如下内容：

catkin_install_python(PROGRAMS
  src/random_number_publisher.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

编译包

回到工作空间，输入catkin_make编译包

5.2.3 Subscriber的编写

5.2.3.1 cpp版本的实现

在 pub_sub_pkg/src 目录下创建一个名为 random_number_subscriber.cpp 的文件，并添加如下内容：

#include <ros/ros.h>
#include <std_msgs/Int32.h>

void randomNumberCallback(const std_msgs::Int32::ConstPtr& msg) {
    ROS_INFO("Received random number: %d", msg->data);
}

int main(int argc, char** argv) {
    ros::init(argc, argv, "random_number_subscriber");
    ros::NodeHandle nh;

    // 创建一个订阅者，订阅 "random_number" 主题
    ros::Subscriber sub = nh.subscribe("random_number", 10, randomNumberCallback);

    // 循环等待回调
    ros::spin();

    return 0;
}

修改 CMakeLists.txt

添加如下内容：

add_executable(random_number_subscriber src/random_number_subscriber.cpp)
target_link_libraries(random_number_subscriber ${catkin_LIBRARIES})

编译包

回到工作空间，输入catkin_make编译包

5.2.3.2 py版本的实现

在 pub_sub_pkg/src 目录下创建一个名为 random_number_subscriber.py 的文件，并添加如下内容：

import rospy
from std_msgs.msg import Int32

def random_number_callback(msg):
    rospy.loginfo("Received random number: %d", msg.data)

def random_number_subscriber():
    # 初始化节点
    rospy.init_node('random_number_subscriber', anonymous=True)
    # 创建一个订阅者，订阅 "random_number" 主题
    rospy.Subscriber('random_number', Int32, random_number_callback)

    # 循环等待回调
    rospy.spin()

if __name__ == '__main__':
    random_number_subscriber()

修改 CMakeLists.txt

添加如下内容：

catkin_install_python(PROGRAMS
  src/random_number_subscriber.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

编译包

回到工作空间，输入catkin_make编译包

5.2.4 运行节点

启动 ROS 核心：
```
roscore
```

启动发布节点：

若运行cpp版本使用命令

rosrun pub_sub_pkg random_number_publisher

若运行py版本使用命令

rosrun pub_sub_pkg random_number_publisher.py

启动订阅节点：

若运行cpp版本使用命令

rosrun pub_sub_pkg random_number_subscriber

若运行py版本使用命令

rosrun pub_sub_pkg random_number_subscriber.py

运行效果如图：

5.3 自定义消息类型

面向更加复杂的应用，我们需要创建自定义消息类型来满足开发需求。我们创建一个功能包名为custom_message，并在该功能包中进行以下操作。

5.3.1 创建自定义消息类型

假设我们创建一个包含一个整数和一个字符串的消息类型。

创建消息文件

在custom_message目录下创建msg文件夹，并在该文件夹中创建一个RandomNumber.msg文件，添加如下内容
```
int32 number
string message
```

修改 package.xml

在 package.xml 文件中添加以下内容

<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

修改 CMakeLists.txt

可对照下面内容进行修改

find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
  message_generation
)

add_message_files(
  FILES
  RandomNumber.msg
)

generate_messages(
  DEPENDENCIES
  std_msgs
)

可以先用catkin_make编译一次，方便之后的源文件调用

然后在之前的Publisher和Subscriber的基础上修改代码

5.3.2 修改发布节点

random_msg_publisher.cpp的内容如下：

#include <ros/ros.h>
#include <custom_message/RandomNumber.h>
#include <cstdlib>  // for rand()
#include <ctime>    // for time()

int main(int argc, char** argv) {
    ros::init(argc, argv, "random_number_publisher");
    ros::NodeHandle nh;

    // 创建一个发布者，发布到 "random_number" 主题
    ros::Publisher random_pub = nh.advertise<custom_message::RandomNumber>("random_number", 10);

    // 初始化随机数生成器
    std::srand(static_cast<unsigned int>(std::time(0)));

    // 设置循环频率
    ros::Rate loop_rate(1);  // 每秒发布一次

    while (ros::ok()) {
        // 创建一个消息并设置随机数
        custom_message::RandomNumber msg;
        msg.number = std::rand() % 100;  // 生成 0 到 99 的随机数
        msg.message = "Random number generated";
        // 发布消息
        random_pub.publish(msg);
        ROS_INFO("Published: number = %d, message = %s", msg.number, msg.message.c_str());

        // 休眠直到下一个循环
        ros::spinOnce();
        loop_rate.sleep();
    }

    return 0;
}

random_msg_publisher.py的内容如下：

import rospy
from custom_message.msg import RandomNumber
import random

def random_number_publisher():
    # 初始化节点
    rospy.init_node('random_number_publisher', anonymous=True)
    # 创建一个发布者，发布到 "random_number" 主题
    pub = rospy.Publisher('random_number', RandomNumber, queue_size=10)
    # 设置循环频率
    rate = rospy.Rate(1)  # 每秒发布一次

    while not rospy.is_shutdown():
        msg = RandomNumber()
        msg.number = random.randint(0, 99)
        msg.message = "Random number generated"
        
        rospy.loginfo("Published: number = %d, message = %s", msg.number, msg.message)
        pub.publish(msg)

        rate.sleep()

if __name__ == '__main__':
    try:
        random_number_publisher()
    except rospy.ROSInterruptException:
        pass

CMakeLists.txt添加

add_executable(random_msg_publisher src/random_msg_publisher.cpp)
target_link_libraries(random_msg_publisher ${catkin_LIBRARIES})

catkin_install_python(PROGRAMS
  src/random_msg_publisher.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

5.3.3 修改订阅节点

random_msg_subscriber.cpp内容如下：

#include <ros/ros.h>
#include <custom_message/RandomNumber.h>

void randomNumberCallback(const custom_message::RandomNumber::ConstPtr& msg) {
    ROS_INFO("Received: number = %d, message = %s", msg->number, msg->message.c_str());
}

int main(int argc, char** argv) {
    ros::init(argc, argv, "random_number_subscriber");
    ros::NodeHandle nh;

    ros::Subscriber sub = nh.subscribe("random_number", 10, randomNumberCallback);
    ros::spin();

    return 0;
}

random_msg_subscriber.py内容如下：

import rospy
from custom_message.msg import RandomNumber

def random_number_callback(msg):
    rospy.loginfo("Received: number = %d, message = %s", msg.number, msg.message)

def random_number_subscriber():
    rospy.init_node('random_number_subscriber', anonymous=True)
    rospy.Subscriber('random_number', RandomNumber, random_number_callback)
    rospy.spin()

if __name__ == '__main__':
    random_number_subscriber()

CMakeLists.txt添加：

add_executable(random_msg_subscriber src/random_msg_subscriber.cpp)
target_link_libraries(random_msg_subscriber ${catkin_LIBRARIES})

catkin_install_python(PROGRAMS
  src/random_msg_subscriber.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

5.3.4 运行节点

启动 ROS 核心：
```
roscore
```

启动发布节点：

若运行cpp版本使用命令

rosrun custom_message random_msg_publisher

若运行py版本使用命令

rosrun custom_message random_msg_publisher.py

启动订阅节点：

若运行cpp版本使用命令

rosrun custom_message random_msg_subscriber

若运行py版本使用命令

rosrun custom_message random_msg_subscriber.py

运行效果如图：

5.4 服务通信

服务通信模型中涉及到三个角色：

ROS master(管理者)
Server(服务端)
Client(客户端)

ROS Master 负责保管 Server 和 Client 注册的信息，并匹配话题相同的 Server 与 Client ，帮助 Server 与 Client 建立连接，连接建立后，Client 发送请求信息，Server 返回响应信息。理论模型如下图：

这里实现一个简单的服务通信，客户端发出两个数字请求，服务端返回它们的和。

5.4.1 创建功能包

我们创建一个名为 add_service 的包，在src文件夹下执行命令：

catkin_create_pkg add_service std_msgs rospy roscpp message_generation

5.4.2 创建自定义服务消息

在功能包中新建srv文件夹，在里面添加AddTwoInts.srv文件，内容如下：
```
int64 a
int64 b
---
int64 sum
```
---上方的是请求数据类型，下方的是响应数据类型。这里定义了一个请求包含两个整数 a 和 b，响应包含它们的和 sum。

确保CMakeLists.txt被修改成如下：

find_package(catkin REQUIRED COMPONENTS
  rospy
  std_msgs
  message_generation
)

add_service_files(
  FILES
  AddTwoInts.srv
)

generate_messages(
  DEPENDENCIES
  std_msgs
)

确保package.xml有如下依赖：

<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

编译包

5.4.3 创建服务端

5.4.3.1 cpp版本的实现

在 add_service/src 目录下创建一个名为 add_service_server.cpp 的文件，并添加以下代码：

#include <ros/ros.h>
#include <add_service/AddTwoInts.h> // 引入自定义服务消息头文件

// 处理加法请求的回调函数
bool handle_add_two_ints(add_service::AddTwoInts::Request &req,
                          add_service::AddTwoInts::Response &res) {
    // 计算请求的两个整数之和
    res.sum = req.a + req.b;
    ROS_INFO("Request: a=%ld, b=%ld; Sending back response: sum=%ld", req.a, req.b, res.sum);
    return true; // 返回成功
}

int main(int argc, char **argv) {
    ros::init(argc, argv, "add_service_server"); // 初始化节点
    ros::NodeHandle n; // 创建节点句柄

    // 创建服务，注册到名为 "add_two_ints" 的服务上
    ros::ServiceServer service = n.advertiseService("add_two_ints", handle_add_two_ints);
    ROS_INFO("Ready to add two ints."); // 打印日志信息
    ros::spin(); // 进入循环，等待服务请求

    return 0; // 返回成功
}

修改 CMakeLists.txt，添加如下内容：

add_executable(add_service_server src/add_service_server.cpp)
target_link_libraries(add_service_server ${catkin_LIBRARIES})

编译

5.4.3.2 py 版本的实现

在 add_service/src 目录下创建一个名为 add_service_server.py 的文件，并添加以下代码：

import rospy
from add_service.srv import AddTwoInts, AddTwoIntsResponse # 引入自定义服务消息

# 处理加法请求的回调函数
def handle_add_two_ints(req):
    result = req.a + req.b # 计算请求的两个整数之和
    rospy.loginfo("Request: a={}, b={}; Sending back response: sum={}".format(req.a, req.b, result))
    return AddTwoIntsResponse(result) # 返回结果

# 服务端初始化
def add_service_server():
    rospy.init_node('add_service_server') # 初始化节点
    s = rospy.Service('add_two_ints', AddTwoInts, handle_add_two_ints) # 注册服务
    rospy.loginfo("Ready to add two ints.") # 打印日志信息
    rospy.spin() # 进入循环，等待服务请求

if __name__ == "__main__":
    add_service_server() # 启动服务端

修改 CMakeLists.txt，添加如下内容：

catkin_install_python(PROGRAMS
src/add_service_server.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

编译

5.4.4 创建客户端

5.4.4.1 cpp版本的实现

在 add_service/src 目录下创建一个名为 add_service_client.cpp 的文件，并添加以下代码：

#include <ros/ros.h>
#include <add_service/AddTwoInts.h> // 引入自定义服务消息头文件

int main(int argc, char **argv) {
    // 检查命令行参数数量
    if (argc != 3) {
        ROS_INFO("Usage: add_service_client <num1> <num2>");
        return 1; // 返回错误
    }

    ros::init(argc, argv, "add_service_client"); // 初始化节点
    ros::NodeHandle n; // 创建节点句柄

    // 创建服务客户端，连接到 "add_two_ints" 服务
    ros::ServiceClient client = n.serviceClient<add_service::AddTwoInts>("add_two_ints");
    add_service::AddTwoInts srv; // 创建服务请求对象
    srv.request.a = atoll(argv[1]); // 将第一个参数转为整数并赋值
    srv.request.b = atoll(argv[2]); // 将第二个参数转为整数并赋值

    // 调用服务并检查是否成功
    if (client.call(srv)) {
        ROS_INFO("Sum: %ld", srv.response.sum); // 打印返回的和
    } else {
        ROS_ERROR("Failed to call service add_two_ints"); // 打印错误信息
        return 1; // 返回错误
    }

    return 0; // 返回成功
}

修改 CMakeLists.txt，添加如下内容：

add_executable(add_service_client src/add_service_client.cpp)
target_link_libraries(add_service_client ${catkin_LIBRARIES})

编译

5.4.4.2 py版本的实现

在 add_service/src 目录下创建一个名为 add_service_client.py 的文件，并添加以下代码：

import sys
import rospy
from add_service.srv import AddTwoInts # 引入自定义服务消息

# 客户端请求加法服务
def add_two_ints_client(x, y):
    rospy.wait_for_service('add_two_ints') # 等待服务可用
    try:
        add_two_ints = rospy.ServiceProxy('add_two_ints', AddTwoInts) # 创建服务代理
        resp = add_two_ints(x, y) # 调用服务
        return resp.sum # 返回结果
    except rospy.ServiceException as e:
        print("Service call failed: {}".format(e)) # 打印错误信息

if __name__ == "__main__":
    # 检查命令行参数数量
    if len(sys.argv) != 3:
        print("Usage: add_service_client.py [num1] [num2]")
        sys.exit(1) # 返回错误

    num1 = int(sys.argv[1]) # 将第一个参数转为整数
    num2 = int(sys.argv[2]) # 将第二个参数转为整数

    rospy.init_node('add_service_client') # 初始化节点
    print("Requesting {} + {}".format(num1, num2)) # 打印请求信息
    sum = add_two_ints_client(num1, num2) # 请求服务
    print("Sum: {}".format(sum)) # 打印结果

修改 CMakeLists.txt，添加如下内容：

catkin_install_python(PROGRAMS
src/add_service_client.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

编译

5.4.5 运行节点

启动 ROS 核心：
```
roscore
```
启动服务端节点：
- 若运行cpp版本使用命令
```
rosrun add_service add_service_server
```
- 若运行py版本使用命令
```
rosrun add_service add_service_server.py
```

启动客户端节点：

若运行cpp版本使用命令

rosrun add_service add_service_client num1 num2

若运行py版本使用命令

rosrun add_service add_service_client.py num1 num2

运行效果如图：

5.5 参数操作

5.5.1 创建功能包

在src文件夹中执行如下命令：

catkin_create_pkg param_example std_msgs rospy roscpp

5.5.2 cpp实现

在 param_example/src 目录下创建一个名为 param_example_node.cpp 的文件，并添加以下代码：

#include <ros/ros.h>

int main(int argc, char **argv) {
    ros::init(argc, argv, "param_example_node"); // 初始化节点
    ros::NodeHandle n; // 创建节点句柄

    // 设置参数
    n.setParam("example_param", 10); // 设置名为 "example_param" 的参数

    // 获取参数
    int param_value;
    if (n.getParam("example_param", param_value)) { // 获取参数值
        ROS_INFO("Got parameter: example_param=%d", param_value); // 打印参数值
    } else {
        ROS_WARN("Could not get parameter: example_param"); // 打印警告
    }

    // 修改参数
    n.setParam("example_param", 20); // 修改参数值

    // 重新获取参数
    if (n.getParam("example_param", param_value)) {
        ROS_INFO("Updated parameter: example_param=%d", param_value); // 打印更新后的参数值
    }

    ros::spinOnce(); // 处理回调
    return 0; // 返回成功
}

在 CMakeLists.txt 文件中添加 C++ 可执行文件的配置：

add_executable(param_example_node src/param_example_node.cpp)
target_link_libraries(param_example_node ${catkin_LIBRARIES})

编译

5.5.3 py实现

在 param_example/src 目录下创建一个名为 param_example_node.py 的文件，并添加以下代码：

import rospy

if __name__ == "__main__":
    rospy.init_node('param_example_node') # 初始化节点

    # 设置参数
    rospy.set_param('example_param', 10) # 设置名为 "example_param" 的参数

    # 获取参数
    param_value = rospy.get_param('example_param', None) # 获取参数值
    if param_value is not None:
        rospy.loginfo("Got parameter: example_param={}".format(param_value)) # 打印参数值
    else:
        rospy.logwarn("Could not get parameter: example_param") # 打印警告

    # 修改参数
    rospy.set_param('example_param', 20) # 修改参数值

    # 重新获取参数
    param_value = rospy.get_param('example_param')
    rospy.loginfo("Updated parameter: example_param={}".format(param_value)) # 打印更新后的参数值

    rospy.spin() # 进入循环

在 CMakeLists.txt 文件中如下配置：

catkin_install_python(PROGRAMS
  src/param_example_node.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

编译

5.5.4 运行节点

启动 ROS 核心：

roscore

运行节点：

cpp版本

rosrun param_example param_example_node

py版本

rosrun param_example param_example_node.py

运行结果：

6. launch文件的使用

launch 文件是一种 XML 格式的文件，用于定义和管理节点的启动过程。通过 launch 文件，可以一次性启动多个节点，设置参数，定义节点间的连接（如话题、服务等），并配置其他相关选项。这使得管理复杂的机器人系统变得更加简单和高效。

6.1 新建launch文件

在功能包下新建 launch 目录, 目录下新建 xxxx.launch 文件。一个简单示例如下

<launch>
    <param name="example_param" value="10"/> <!-- 设置全局参数 -->

    <node pkg="param_example" type="param_example_node" name="param_example_node" output="screen">
        <param name="node_param" value="5"/> <!-- 设置节点特定参数 -->
    </node>
</launch>

6.2 launch文件的标签和属性

在 ROS 的 launch 文件中，有多种属性和标签可用于配置节点的启动、参数设置、依赖管理等，常见的属性和标签如下：

<launch>

根元素：每个 launch 文件都以 <launch> 标签开始，表示该文件的开始。
<node>
- pkg：节点所属的 ROS 包名称。
- type：节点的可执行文件名。
- name：节点的名称（可以与可执行文件名相同，但推荐使用不同的名称以便于识别）。
- output：节点的输出方式，可以是 screen（在终端显示）或 log（输出到日志文件）。
- args：传递给节点的命令行参数。
- respawn：如果节点崩溃是否自动重启，取值为 true 或 false。
- respawn_delay：当 respawn 为 true 时，重启节点的延迟时间（单位为秒）。
- required：如果节点是必需的，设置为 true，否则设置为 false。
示例：
```
<node pkg="my_package" type="my_node" name="my_node_name" output="screen" respawn="true" respawn_delay="2"/>
```
子级标签有：
- env 环境变量设置
- remap 重映射节点名称
- rosparam 参数设置
- param 参数设置
<param>

设置参数，主要属性如下：
- name：参数名称。
- value：参数的值，可以是常量、字符串、布尔值等。
- type：参数类型，支持 int, double, string, bool 等。
示例：
```
<param name="param_name" value="param_value"/>
```
<rosparam>

用于加载参数文件，支持 YAML 格式。
- file：指定要加载的 YAML 文件的路径。
- command：可以是 load 或 dump，分别用于加载和导出参数。
示例：
```
<rosparam file="$(find my_package)/config/params.yaml" command="load"/>
```
<include>

用于从其他 launch 文件中引用节点。
- file：要包含的 launch 文件的路径，可以使用 $(find package_name) 来引用包内的文件。
示例：
```
<include file="$(find another_package)/launch/another_launch_file.launch"/>
```
<group>

将多个节点或参数分组，可以设置特定的属性。
- name：分组名称，通常用于命名空间。
- ns：定义命名空间。
示例：
```
<group ns="my_namespace">
    <node pkg="my_package" type="my_node" name="my_node_name"/>
</group>
```
<test>

用于运行测试节点，主要属性如下：
- pkg：测试节点所属的 ROS 包名称。
- type：测试节点的可执行文件名。
- name：测试节点的名称。
示例：
```
<test pkg="my_package" type="test_node" name="test_node_name"/>
```
<arg>

定义命令行参数，主要属性如下：
- name：参数名称。
- default：默认值。
示例：
```
<arg name="my_arg" default="default_value"/>
```
使用 $(arg my_arg) 可以引用该参数。
<remap>

用于重映射话题名称。
- from：原始话题名称。
- to：新话题名称。
```
<remap from="/old_topic" to="/new_topic"/>
```

6.3 调用launch文件

使用命令

roslaunch 包名 xxx.launch

roslaunch 命令执行launch文件时，首先会判断是否启动了 roscore，如果启动了，则不再启动，否则，会自动调用 roscore。

7. 常用的ROS命令

7.1 ROS信息命令

7.1.1 rosnode

节点相关命令

rosnode ping    测试到节点的连接状态
rosnode list    列出活动节点
rosnode info    打印节点信息
rosnode machine    列出指定设备上节点
rosnode kill    杀死某个节点
rosnode cleanup    清除不可连接的节点

7.1.2 rostopic

话题相关命令

rostopic bw     显示主题使用的带宽
rostopic delay  显示带有 header 的主题延迟
rostopic echo   打印消息到屏幕
rostopic find   根据类型查找主题
rostopic hz     显示主题的发布频率
rostopic info   显示主题相关信息
rostopic list   显示所有活动状态下的主题
rostopic pub    将数据发布到主题
rostopic type   打印主题类型

7.1.3 rosmsg

消息相关命令

rosmsg show    显示消息描述
rosmsg info    显示消息信息
rosmsg list    列出所有消息
rosmsg md5    显示 md5 加密后的消息
rosmsg package    显示某个功能包下的所有消息
rosmsg packages    列出包含消息的功能包

7.1.4 rosservice

服务相关命令

rosservice args 打印服务参数
rosservice call    使用提供的参数调用服务
rosservice find    按照服务类型查找服务
rosservice info    打印有关服务的信息
rosservice list    列出所有活动的服务
rosservice type    打印服务类型
rosservice uri    打印服务的 ROSRPC uri

7.1.5 rossrv

服务信息相关命令

rossrv show    显示服务消息详情
rossrv info    显示服务消息相关信息
rossrv list    列出所有服务信息
rossrv md5    显示 md5 加密后的服务消息
rossrv package    显示某个包下所有服务消息
rossrv packages    显示包含服务消息的所有包

7.1.6 rosparam

参数相关命令

rosparam set    设置参数
rosparam get    获取参数
rosparam load    从外部文件加载参数
rosparam dump    将参数写出到外部文件
rosparam delete    删除参数
rosparam list    列出所有参数

7.1.7 rosbag

记录和重放相关命令

check        确定 bag 在当前系统中是否可播放，或者是否可以迁移
compress     压缩一个或多个包文件
decompress   解压缩一个或多个包文件
decrypt      解密一个或多个包文件
encrypt      加密一个或多个 bag 文件
filter       过滤bag的内容
fix          修复 bag 文件中的消息，以便它可以在当前系统中播放。
info         总结一个或多个文件包的内容。
play         以时间同步的方式播放一个或多个包文件的内容。
record       录制包含指定 topic 内容的 bag 文件。
reindex      重新索引一个或多个 bag 文件。

7.1.8 rosversion

显示ROS功能包的版本信息

-h, --help          显示此帮助消息并退出
-s, --skip-newline  跳过尾随换行符
-d, --distro        输出 ROS 发行版名称
-a, --all           显示所有 ROS 软件包名称及其版本

7.2 ROS shell 命令

ROS shell命令又被称为rosbash。相关命令如下：

| 命令 | 命令释义 | 详细说明 | 参考模板 | | ----- | ------------------------- | ------------------------- | ----------------------------- | | roscd | ros+cd(changes directory) | 移动到指定的ROS功能包目录 | roscd [功能包名称] | | rosls | ros+ls(lists files) | 显示ROS功能包的文件和目录 | rosls [功能包名称] | | rosed | ros+ed(editor) | 编辑ROS功能包的文件 | rosed [功能包名称] [文件名称] | | roscp | ros+cp(copies files) | 复制ROS功能包的文件 | — | | rospd | ros+pushd | 添加目录至ROS目录索引 | — | | rosd | ros+directory | 显示ROS目录索引中的目录 | — |

7.3 ROS 执行命令

ROS 执行命令管理ROS节点的运行。

| 命令 | 命令释义 | 详细说明 | 参考模板 | | --------- | ---------- | ------------------------------------------------------------ | ------------------------------------- | | roscore | ros+core | master（ROS名称服务） + rosout（日志记录） + parameter server（参数管理） | roscore [选项] | | rosrun | ros+run | 运行单个节点 | rosrun [功能包名称] [节点名称] | | roslaunch | ros+launch | 运行多个节点或设置运行选项 | roslaunch [功能包名称] [launch文件名] | | rosclean | ros+clean | 检查或删除ROS日志文件 | rosclean [选项] |

7.4 ROS catkin命令

ROS catkin命令ROS的catkin命令用于使用catkin 构建系统来构建功能包。

| 命令 | 详细说明 | 参考模板 | | ------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ | | catkin_create_pkg | 自动生成功能包 | catkin_create_pkg [功能包名称] [依赖性功能包1] [依赖性功能包2] … | | catkin_make | 基于catkin 构建系统的构建 | catkin_make --[选项] | | catkin_eclipse | 把用catkin 构建系统生成的功能包修改，使得可以在Eclipse 环境中使用 | catkin_eclipse | | catkin_prepare_release | 发布时用到的日志整理和版本标记 | catkin_prepare_release | | catkin_generate_changelog | 发布时生成或更新CHANGELOG.rst文件 | catkin_generate_changelog | | catkin_init_workspace | 初始化catkin 构建系统的工作目录 | catkin_init_workspace | | catkin_find | 搜索catkin | catkin_find [功能包名称] |

7.5 ROS功能包命令

ROS 功能包命令用于操作ROS功能包，比如显示功能包信息、安装相关功能包等。

| 命令 | 命令释义 | 详细说明 | 参考模板 | | ------------- | ------------------ | ------------------------------------- | ----------------------------- | | rospack | ros+pack(age) | 显示与ROS功能包相关的信息 | rospack [选项] [功能包名称] | | rosinstall | ros+install | 安装ROS附加功能包 | —— | | rosdep | ros+dep(endencies) | 安装该功能包的依赖性文件 | rosdep [选项] | | roslocate | ros+locate | 与ROS功能包信息有关的命令 | roslocate [选项] [功能包名称] | | roscreate-pkg | ros+create-pkg | 自动生成ROS功能包 | （用于旧的rosbuild系统） | | rosmake | ros+make | 构建ROS功能包（用于旧的rosbuild系统） | —— |

8. 参考资料

Linux 中使用 Terminator 进行分屏

Sat, 02 Nov 2024 00:00:00 GMT

1. 前言

在进行复杂的任务时，通常需要开多个终端，有时候非常凌乱，而Terminator则是一个很好的工具，能够很好地帮助我们帮助我们同时管理多个终端。Terminator 的核心功能在于其便捷的“分屏”能力，允许用户在单个窗口内垂直或水平分割屏幕，从而同时显示多个终端会话。对于开发者、系统管理员或需要处理多任务的用户来说，Terminator 是一个高效的工具。

2.安装

在Ubuntu上，可以使用如下命令进行安装

sudo apt update
sudo apt install terminator

3. 基本使用

启动

使用快捷键ctrl+Alt+T或者在终端中输入terminator
分屏
- 垂直分屏：按下 Ctrl + Shift + E
- 水平分屏：按下 Ctrl + Shift + O
- 可以通过鼠标拖动分隔线来调整各个窗口的大小
管理分屏
- 关闭窗口：右键单击窗口，选择 “关闭” 或使用 Ctrl + Shift + W。
- 切换焦点：使用鼠标单击在不同窗口之间切换焦点。
- 组合窗口：使用鼠标可以将窗口拖拽到其他窗口旁边，形成组合。
设置配置
- 右键选择 “首选项” 可以进行个性化配置，包括配色方案、字体、背景透明度等。
- Terminator 支持保存多种配置，可以根据不同任务选择对应的终端配置，提高使用效率。

4. 总结

以上就是terminator的常用命令，非常简单，只是顺手记录一下~

华硕笔记本 Linux 系统的充电阈值控制

Thu, 31 Oct 2024 00:00:00 GMT

1. 前言

如果电脑为华硕笔记本，那么是可以通过在Windows中安装华硕管家，来控制电池的充电阈值，使得电脑的电池保持健康的状态，如图：

但是我们安装双系统后，在Linux系统中，该功能无法使用。目前，华硕官方没有发布在Linux中的驱动程序，但是有一个开源仓库可以解决这个问题。

2. 仓库介绍

tshakalekholoane/bat: Battery management utility for Linux laptops.仓库的目标是在 Windows 上复制适用于华硕笔记本电脑的华硕电池健康充电实用程序的功能，旨在延长电池的使用寿命

程序的说明如下（已翻译）：

NAME
    bat - Linux 笔记本电脑的电池管理实用程序

SYNOPSIS
    bat [-d | --debug] [-h | --help] [-v | --version]
        <command> [<arg>]

OPTIONS
    -d, --debug
        显示调试信息。

    -h, --help
        打印此帮助文档。

    -v, --version
        显示版本信息和退出。

COMMANDS
    capacity
        打印当前电池电量。

    health
        打印电池健康状态。

    persist
        在重启之间保持当前阈值。

    reset
        取消重启之间的充电阈值的持久设置。

    status
        打印充电状态。

    threshold num
        打印当前充电阈值限制。

        如果指定了 num（应该是 1 到 100 之间的一个值），则这将设置一个新的充电阈值限制。

2. 安装流程

在发布页面下载二进制文件，并将他移动到你想保存的位置，假设移动到$HOME/目录下，执行以下命令，赋予该二进制文件执行权限

chmod +x $HOME/bat

设置软链接，这样任何用户可以从系统上的任何位置执行程序

sudo ln -s $HOME/bat /usr/local/bin/bat

3. 使用示例

查看当前充电阈值
```
bat threshold
```
设置充电阈值
```
sudo bat threshold 80
```
重新启动时保持默认值设置
```
sudo bat persist
```

4. 参考资料

https://github.com/tshakalekholoane/bat

Python 内置库 argparse 的使用

Wed, 30 Oct 2024 00:00:00 GMT

1. 前言

argparse 是 Python 标准库中用于解析命令行参数的模块，提供了一种简单、直观的方式来定义命令行接口，让程序可以直接从命令行获取输入并据此执行不同的操作，在许多深度学习的工程代码中经常用到。

2. 基本参数类型

我们通过命令行运行 Python 文件时，可以向文件传递不同类型的参数。主要有以下几种类型：

位置参数（Positional arguments）：位置参数是指在命令行中按照特定顺序传递给程序的参数，它们不带任何前缀。示例：
```
python main.py arg1 arg2
```
选项参数（Optional arguments）：选项参数是可选的参数，它们通常以短横线（-）或双短横线（--）开头。示例
```
python main.py --config ./config/test/aagcn_B_3d.yaml --phase test
```
标志参数（Flag arguments）：标志参数是一种特殊的选项参数，它们不带值，只用于表示某个状态或开关是否打开。通常以短横线和单个字符表示，例如 -v 表示 verbose 模式。
```
python main.py -v
```

3. 基本用法

3.1 创建解析器

使用 argparse 的第一步是创建一个 ArgumentParser 对象：

parser = argparse.ArgumentParser(description='Descriptive information')

description是该对象的描述信息，可使用python main.py -h命令查看。

3.2 添加参数

可以使用parser.add_argument方法像解析器添加参数。

3.2.1 name属性

参数名称（name）是传递给 add_argument() 的第一个参数，直接指定了命令行参数的名称。根据参数前缀的不同，可以分为位置参数和可选参数：

添加位置参数

位置参数是一个字符串，位置参数在使用命令行输入的时候位置不能调换，且不用输入参数名，示例：
```
parser.add_argument('num1', type=int, help='The first number')
parser.add_argument('num2', type=int, help='The second number')
```
```
python main.py 2 3
```
添加可选参数

可选参数通常以短横线（-）或双短横线（--）开头，短横线后面一般是缩写，双短横线后面是参数的完整名称。短横线名称可以选择，双短横线名称必须存在。可选参数在使用命令行输入的时候位置可以调换，且要输入参数名，示例：
```
parser.add_argument('-n1','--number1', type=int, help='The first number')
parser.add_argument('-n2','--number2', type=int, help='The second number')
```
```
python main.py -n1 1314 -n2 520
python main.py --number2 520 --number1 1314
```

3.2.2 type属性

type 属性用于指定参数的预期数据类型，帮助解析和验证命令行输入的数据格式。如果输入的数据类型不符合 type 指定的格式，argparse 会自动抛出错误。type 属性支持多种常见的数据类型，还可以自定义数据转换函数。常见的数据类型如下

str：默认类型，将输入解析为字符串类型，适用于大多数文本、路径等输入
```
parser.add_argument("--name", type=str, help="Your name")
```
int：将输入解析为整数，适合计数、编号等整数类型的参数；如果输入非整数，会自动报错
```
parser.add_argument("--age", type=int, help="Your age")
```
float：将输入解析为浮点数，适合需要精确到小数的参数，比如学习率、权重等
```
parser.add_argument("--learning-rate", type=float, help="Learning rate for training")
```

除此之外，我们还可以通过传递自定义函数，将输入值解析为自定义格式。例如，可以定义一个将输入转换为复数的函数或仅允许特定格式的字符串输入

def parse_complex(value):
    return complex(value)

parser.add_argument("--complex-number", type=parse_complex, help="A complex number input")

3.2.3 help属性

可以通过这个属性为参数添加描述，用户在命令行输入-h或--help时会输入相应的帮助信息。

3.2.4 default属性

default 属性用于为参数设置默认值。如果命令行中没有提供该参数，解析后的结果会使用 default 指定的默认值。示例

parser.add_argument("--timeout", type=int, default=30, help="Set the timeout in seconds (default: 30)")
args = parser.parse_args()

3.2.5 required属性

当 required=True 时，程序运行时必须提供该参数，否则 argparse 会自动提示错误并输出帮助信息。

parser.add_argument("--name", required=True,type=str, help="Your name")

3.2.6 action属性

action 属性用于控制命令行参数的解析行为。不同的 action 值会导致参数的处理方式不同，特别适用于控制布尔开关、多值参数以及参数累积。action的常见可选值如下：

"store"：默认值，将用户输入的值存储在变量中。
"store_const"：用于将一个预定义的常量值存储为参数值，而不是从命令行中获取该参数的输入。即不需要输入具体的值，只要参数存在，就赋予一个固定的值。示例：
```
parser.add_argument("--flag", action="store_const", const=42, default=0, help="Store a constant value of 42 if this flag is present")
```
当执行命令python main.py --flag时，参数值为常量42。
"store_true"：将布尔值 True 存储为参数值，常用于启用某个特性，示例：
```
parser.add_argument("--debug", action="store_true", help="Enable debug mode")
```
--debug会将 args.debug 设置为 True，不指定则为 False
"store_false"：将布尔值 False 存储为参数值，常用于禁用某个特性，示例：
```
parser.add_argument("--no-cache", action="store_false", help="Disable caching")
```
--no-cache 会将 args.no_cache 设置为 False，不指定则为 True。
"append"：将每次传入的值追加到一个列表中，适用于接受多个输入值的场景，示例：
```
parser.add_argument("--tag", action="append", help="Add a tag to the list of tags")
```
命令行输入 --tag dev --tag test 后，args.tag 的值为 ["dev", "test"]。

3.2.7 dest属性

dest 属性用于指定参数在解析后存储的变量名。通过设置 dest，可以在代码中访问参数值时使用更直观或自定义的名称，而不依赖于命令行中传入的参数名称。示例：

import argparse

parser = argparse.ArgumentParser(description="Example of dest attribute")

# 使用 dest 定义变量名称为 'input_path'
parser.add_argument("--input", dest="input_path", type=str, help="Path to the input file")
parser.add_argument("-o", "--output", dest="output_path", type=str, help="Path to the output file")

args = parser.parse_args()

print("Input path:", args.input_path)
print("Output path:", args.output_path)

3.2.8 nargs属性

nargs 属性用于指定命令行参数能够接受的值的数量。允许我们控制参数的输入数量，包括支持单个、多个、可变数量的值，甚至可以将所有剩余的命令行参数捕获到一个列表中。

nargs属性常见的取值如下：

整数值：指定参数必须接受确切数量的值，如nargs=2 表示参数需要接受两个值，示例：
```
parser.add_argument("--range", nargs=2, type=int, help="Specify a start and end value")
```
命令行输入python main.py --range 1 10后得到的变量值为args.range = [1, 10]
?0：表示参数值是可选的，最多可以接受一个值。若不提供值，则使用默认值（如果设置了默认值）或 None，示例：
```
parser.add_argument("--verbosity", nargs="?", const="INFO", help="Set verbosity level (default: INFO if no value is provided)")
```
- 命令行输入python main.py --verbosity DEBUG得到的是args.verbosity = "DEBUG"
- 命令行输入python main.py --verbosity得到的是args.verbosity = "INFO"
*：接受零个或多个值，所有输入将被收集到一个列表中，示例：
```
parser.add_argument("--files", nargs="*", help="List of files to process")
```
命令行输入python main.py --files file1.txt file2.txt file3.txt得到的是args.files = ["file1.txt", "file2.txt", "file3.txt"]
+：接受一个或多个值，所有值将被收集到一个列表中。如果没有提供值，会报错，示例：
```
parser.add_argument("--items", nargs="+", help="List of items")
```
命令行输入python main.py --items apple banana orange得到的是args.items = ["apple", "banana", "orange"]
argparse.REMAINDER：将命令行中所有剩余的参数捕获到一个列表中。通常用于将所有剩余的参数传递给另一个命令或子程序，示例：
```
parser.add_argument("command", nargs=argparse.REMAINDER, help="Command to run with all remaining args")
```
在命令行输入python script.py --command ls -l /home/user得到的是args.command = ["ls", "-l", "/home/user"]

3.2.9 choices属性

用于限制参数的值只能在指定的选项范围内，如果传入的值不在范围内，argparse 会自动报错。示例：

parser.add_argument("--mode", choices=["train", "test", "validate"], help="Specify the operation mode")

3.2.10 metavar属性

用于在帮助信息中显示参数的占位符名称，而不影响变量名称。可以让帮助信息更简洁明了，示例：

parser.add_argument("--input", metavar="INPUT_FILE", help="Path to the input file")

3.3 解析参数

添加完参数之后，我们使用如下语句进行解析：

args = parser.parse_args()
#解析命令行参数

3.4 使用参数

解析完成后，我们使用语句arg.参数名就可以直接使用了。

注意：name属性中的短横线（-）被解析成Python变量时会变成下划线，示例：

import argparse

parser = argparse.ArgumentParser(description="Example of argparse usage")
parser.add_argument("--train-path", type=str, help="Path to training data")
parser.add_argument("--epochs", type=int, default=10, help="Number of training epochs")

args = parser.parse_args()

# 访问参数
print(args.train_path)
print(args.epochs)

4. 一个完整的示例

import argparse

# 创建 ArgumentParser 对象，并设置程序的描述和 epilog
parser = argparse.ArgumentParser(
    prog="FileProcessor",
    description="This program processes an input file and outputs the results based on specified options.",
    epilog="For more details, please visit our documentation."
)

# 添加必需的输入文件参数（位置参数）
parser.add_argument(
    "input_file",  # 位置参数，不需要 -- 前缀
    type=str,
    help="Path to the input file that will be processed."
)

# 添加可选参数：输出文件
parser.add_argument(
    "-o", "--output",  # 支持 -o 和 --output 两种形式
    type=str,
    default="output.txt",  # 默认值
    metavar="OUTPUT_FILE",  # 在帮助信息中显示的参数名称
    help="Specify the output file path. Default is 'output.txt'."
)

# 添加可选参数：处理模式
parser.add_argument(
    "-m", "--mode",
    choices=["fast", "slow", "custom"],  # 限制选项
    default="fast",
    help="Choose the processing mode. Available options are 'fast', 'slow', or 'custom'. Default is 'fast'."
)

# 添加可选参数：详细模式（布尔开关）
parser.add_argument(
    "-v", "--verbose",
    action="store_true",  # 如果提供此参数，则将其值设为 True，否则为 False
    help="Enable verbose mode to get detailed output."
)

# 添加可选参数：重复次数（整数类型，默认值为 1）
parser.add_argument(
    "-r", "--repeat",
    type=int,
    default=1,
    help="Specify the number of times to repeat the processing. Default is 1."
)

# 添加可选参数：设置日志级别（可选的多值参数）
parser.add_argument(
    "--log-level",
    nargs="?",
    const="INFO",  # 如果没有提供值，则默认为 INFO
    help="Set the logging level. If no level is specified, 'INFO' is used by default."
)

# 添加可选参数：标签（允许多个值）
parser.add_argument(
    "--tags",
    nargs="*",
    help="Specify tags associated with this processing task. You can pass multiple tags."
)

# 解析命令行参数
args = parser.parse_args()

# 打印解析后的参数（供调试）
print("Parsed arguments:")
print("Input file:", args.input_file)
print("Output file:", args.output)
print("Mode:", args.mode)
print("Verbose:", args.verbose)
print("Repeat count:", args.repeat)
print("Log level:", args.log_level)
print("Tags:", args.tags)

# 基于解析的参数执行逻辑
if args.verbose:
    print("[Verbose Mode Enabled] Detailed processing information will be shown.")
    
for i in range(args.repeat):
    print(f"\nProcessing '{args.input_file}' in '{args.mode}' mode (Run {i+1}/{args.repeat})...")
    # 模拟处理逻辑
    if args.mode == "fast":
        print("Processing quickly...")
    elif args.mode == "slow":
        print("Processing slowly...")
    elif args.mode == "custom":
        print("Processing with custom settings...")

    # 处理标签
    if args.tags:
        print("Applying tags:", ", ".join(args.tags))

    print(f"Output will be saved to '{args.output}'.")

# 日志信息
if args.log_level:
    print(f"Log level set to: {args.log_level}")

5. 参考资料

Windows 查看和开放特定端口

Tue, 29 Oct 2024 00:00:00 GMT

1. 设置步骤

打开控制面板：按下 Win + R 键，然后输入 “control” 并按下 Enter 键，打开控制面板。
进入 Windows 防火墙设置：在控制面板中，选择 “系统和安全”，然后选择 “Windows Defender 防火墙”。
创建入站规则：在左侧导航栏中，点击 “高级设置”。
创建新的入站规则：在右侧窗口中，点击 “入站规则”，然后在右侧面板点击 “新建规则…”。
配置规则属性：在向导中选择 “端口” 选项，然后点击 “下一步”。
选择端口类型：选择 “特定本地端口”，然后输入要打开的端口号（例如，1883）。选择 “允许连接”，然后点击 “下一步”。
选择连接的配置：可以选择 “公共”、“专用” 或 “域”，具体根据你的网络设置选择。
命名规则：给规则起一个名称和可选的描述，然后点击 “下一步”。
完成向导：检查配置，然后点击 “完成”。

2. 参考资料

【windows】查看和开放特定的端口_windows开放指定端口-CSDN博客

使用 tmux 分离终端和会话

Mon, 28 Oct 2024 00:00:00 GMT

1. 前言

在使用ssh远程连接服务器时，当我们关闭终端或者断开连接，在终端运行的代码也随之停止。特别是使用服务器训练模型时，我们不可能一直保持终端连接，这时我们可以使用tmux（terminal multiplexer）（终端复用器）来使终端和会话分离（detach），这样关闭终端时运行的程序不会停止。这里只对会话分离功能进行记录，因为窗格操作目前基本不会使用。

2. 基础命令

2.1 安装

# Ubuntu 或 Debian
sudo apt-get install tmux
 
# CentOS 或 Fedora
sudo yum install tmux
 
# Mac
brew install tmux

2.2 启动和退出

启动tmux窗口
```
tmux
```
也可以在启动时指定session的名字，这样在解绑后可以快速重新进入该session：
```
tmux new -s your-session-name
```
退出tmux窗口
```
exit
```

2.3 分离会话

tmux detach

执行该命令后，就会退出当前 tmux 窗口，但是会话和里面的进程仍然在后台运行。

2.4 查找和接入会话

查看当前所有的 tmux 会话
```
tmux ls
```

重新接入某个已存在的会话

# 使用会话编号
tmux attach -t 0

# 使用会话名称
tmux attach -t <session-name>

2.5 杀死会话

# 使用会话编号
tmux kill-session -t 0

# 使用会话名称
tmux kill-session -t <session-name>

使用该命令后，会话和里面的进程会被杀死

2.6 切换会话

# 使用会话编号
tmux switch -t 0

# 使用会话名称
tmux switch -t <session-name>

这个命令可以从某个会话直接切换到另一个会话

2.7 重命名会话

tmux rename-session -t 0 <new-name>

3. 参考资料

WSL 的使用

Sun, 27 Oct 2024 00:00:00 GMT

1. WSL的常用命令

1.1 基础 WSL 命令

启动默认 WSL 发行版：
```
wsl
```

启动特定的 WSL 发行版：

wsl -d <发行版名称>

例如：

wsl -d Ubuntu-20.04

查看所有已安装的 WSL 发行版：
```
wsl --list --verbose
```
或者简写：
```
wsl -l -v
```

设置默认 WSL 发行版：

wsl --set-default <发行版名称>

例如：

wsl --set-default Ubuntu-20.04

1.2. WSL 版本管理

检查 WSL 发行版版本（1 或 2）：
```
wsl --list --verbose
```

设置指定 WSL 发行版为 WSL 2：

wsl --set-version <发行版名称> 2

例如：

wsl --set-version Ubuntu-20.04 2

设置新的默认 WSL 版本（将新安装的发行版默认设置为 WSL 2）：
```
wsl --set-default-version 2
```

1.3. 启动和停止 WSL

停止所有运行中的 WSL 发行版：
```
wsl --shutdown
```

终止特定 WSL 发行版：

wsl --terminate <发行版名称>

例如：

wsl --terminate Ubuntu-20.04

1.4. WSL 文件系统操作

从 WSL 访问 Windows 文件系统：
- 在 WSL 中，可以通过 /mnt/c 等路径访问 Windows 的 C 盘文件。
```
cd /mnt/<windows路径>
```
例如:
```
cd /mnt/c/Users/lbm/
```
从 Windows 访问 WSL 文件系统：

在文件资源管理器的地址栏中输入：
```
\\wsl$\<发行版名称>
```
例如：
```
\\wsl$\Ubuntu-20.04
```

1.5. 发行版的安装和卸载

安装新的 WSL 发行版：

可以通过 Microsoft Store 下载和安装新的 WSL 发行版（如 Ubuntu、Debian 等）。

卸载 WSL 发行版：

wsl --unregister <发行版名称>

例如：

wsl --unregister Ubuntu-20.04

1.6. 发行版的导入与导出

导出 WSL 发行版（备份）：

wsl --export <发行版名称> <文件路径>

例如：

wsl --export Ubuntu-20.04 D:\backup\ubuntu_backup.tar

导入 WSL 发行版（恢复）：

wsl --import <自定义名称> <安装路径> <备份文件路径>

例如：

wsl --import MyUbuntu D:\WSL\Ubuntu D:\backup\ubuntu_backup.tar

1.7. 设置和调试

查看 WSL 帮助：
```
wsl --help
```
检查 WSL 状态和配置：
```
wsl --status
```

2. 更改WSL的安装路径

Windows似乎不支持直接更改WSL的默认安装路径，但支持安装发行版的时候自定义安装路径，或者将已经安装好的发行版迁移到其他盘符。

2.1 自定义安装路径

若想自定义安装路径，不能直接从电脑的Microsoft Store中直接安装，这样的话会直接被安装到默认路径中。

在https://learn.microsoft.com/zh-cn/windows/wsl/install-manual中找到发行版的下载链接，如图
选择需要安装的发行版，这里以Kali Linux为例，下载完成后解压，得到如图文件夹
选择合适的版本，我选择的是x64，将后缀改为.zip，解压，得到如图文件夹

install.tar.gz就是我们安装需要用到的文件

执行安装命令

wsl --import <自定义名称> <目标路径> <解压目录路径>\install.tar.gz

设置WSL版本
```
wsl --set-version <自定义名称> 2
```
启动安装的发行版
```
wsl --set-default <发行版名称>
```
创建快捷方式：右键点击桌面，选择 新建 > 快捷方式，输入如下命令
```
wsl -d <发行版名称>
```
点击 下一步，为快捷方式命名，然后点击完成。创建完成后，右键点击快捷方式，可以选择 固定到“开始”屏幕 或 固定到任务栏。

2.2 将WSL安装的发行版迁移至其他盘符

查看安装的发行版
```
wsl -l --all  -v
```

导出分发版为.tar文件到d盘

wsl --export Ubuntu-20.04 d:\wsl-ubuntu20.04.tar

注销当前分发版
```
wsl --unregister Ubuntu-20.04
```

重新导入并安装WSL在d:\wsl-ubuntu20.04

wsl --import Ubuntu-20.04 d:\wsl-ubuntu20.04 d:\wsl-ubuntu20.04.tar --version 2

设置默认登陆用户为安装时用户名
```
ubuntu2004 config --default-user Username
```
删除.tar文件
```
del d:\wsl-ubuntu20.04.tar
```

3. 参考资料

Win10/11下安装WSL并修改WSL默认安装目录到其他盘_wsl选择安装目录-CSDN博客

Markdown 简明教程

Sat, 26 Oct 2024 00:00:00 GMT

Markdown是一种轻量级标记语言，排版语法简洁，让人们更多地关注内容本身而非排版。它使用易读易写的纯文本格式编写文档，可与HTML混编，可导出 HTML、PDF 以及本身的 .md 格式的文件。因简洁、高效、易读、易写，Markdown被大量使用，如Github、Wikipedia、简书等。

1. 速查表

| 元素 | Markdown 语法 | | --------------------------- | ------------------------------------------------------------ | | 标题（Heading） | # H1 | | 粗体（Bold） | **bold text** | | 斜体（Italic） | *italicized text* | | 引用块（Blockquote） | > blockquote | | 有序列表（Ordered List） | 1. First item | | 无序列表（Unordered List） | - First item | | 代码（Code） | `code` | | 分隔线（Horizontal Rule） | --- | | 链接（Link） | [title](https://www.example.com) | | 图片（Image） | ![alt text](image.jpg) | | 表格（Table） | |标题|标题||---|---||内容|内容| | | 代码块（Fenced Code Block） | ```{"firstName": "John""lastName": "Smith","age": 25}``` | | 删除线（Strikethrough） | ~~The world is flat.~~ | | 任务列表（Task List） | - [x] Write the press release- [ ] Update the website- [ ] Contact the media |

2. 具体语法

2.1. 标题语法

在单词或短语前面添加井号 (#) 。# 的数量代表了标题的级别。例如，添加三个 # 表示创建一个三级标题 (<h3>)

### My Header

考虑到兼容问题，#和标题直接要有空格

2.2. 段落语法

使用空白行将一行或多行文本进行分隔。不要用空格（spaces）或制表符（ tabs）缩进段落。

2.3. 换行语法

可以在一行的末尾添加两个或多个空格，然后按回车键，即可创建一个换行(<br>)。几乎每个 Markdown 应用程序都支持两个或多个空格进行换行，称为结尾空格(trailing whitespace) 的方式。
几乎每个 Markdown 应用程序都支持另一种换行方式：HTML 的 <br> 标签。
```
hello world<br>
hello world
```

2.4. 强调语法

2.4.1 粗体

在单词或短语的前后各添加两个星号（asterisks）

**加粗**

2.4.2 斜体

在单词或短语前后添加一个星号（asterisk）

*斜体*

2.4.3 粗体和斜体

要同时使用用粗体和斜体时，在单词或短语的前后各添加三个星号。

***加粗和斜体***

2.5. 引用语法

要创建块引用，请在段落前添加一个>符号。

> 引用块

如果引用想包含多个段落，要在段落之间的空白行添加一个>符号。

> 第一段
>
> 第二段

块引用可以嵌套。在要嵌套的段落前添加一个>>符号。

> 引用块
>> 引用块里面的引用块

2.6. 列表语法

有序列表用数字

1. 第一点
2. 第二点

无序列表用+ , - ,*，一般用-

- 内容
- 内容

2.7. 代码语法

行内代码，将将目标包裹在反引号(`)中。

你好，`code`行内代码

如果单词或短语中包含一个或多个反引号，则可以通过将单词或短语包裹在双反引号(``)中.

你好，``code``行内代码

代码块使用三个反引号(```)，要添加语法突出显示，可以代码块之前的反引号旁边指定一种语言。

```python
print("hello world")
```

2.8. 分割线语法

要创建分隔线，在单独一行上使用三个或多个破折号 (---) ，并且不能包含其他内容。为了兼容性，分隔线的前后都要添加空白行。

内容1

---

内容2

2.9. 链接语法

超链接Markdown语法代码：

[超链接显示名](超链接地址 "超链接title")

使用尖括号可以很方便地把URL或者email地址变成可点击的链接。

<https://markdown.com.cn>

2.10. 图片语法

图片语法比链接语法多一个感叹号 (!)，然后在方括号增加替代文本，图片链接放在圆括号里，括号里的链接后可以增加一个可选的图片标题文本。

![图片alt](图片链接 "图片title")

2.11. 表格

使用三个或多个连字符（---）创建每列的标题，并使用管道（|）分隔每列。您可以选择在表的任一端添加管道。

| Syntax      | Description |
| ----------- | ----------- |
| Header      | Title       |
| Paragraph   | Text        |

您可以通过在标题行中的连字符的左侧，右侧或两侧添加冒号（:），将列中的文本对齐到左侧，右侧或中心。中间对齐示例

| Syntax      | Description |
| :---------: | :---------: |
| Header      | Title       |
| Paragraph   | Text        |

2.12. 删除线

在单词前后使用两个波浪号~~。

~~删除~~

2.13. 使用 Emoji 表情

有两种方法可以将表情符号添加到Markdown文件中：

将表情符号复制并粘贴到Markdown格式的文本中
键入emoji shortcodes。

在大多数情况下，可以简单地从Emojipedia等来源复制表情符号并将其粘贴到文档中。还可以通过键入表情符号短代码来插入表情符号。这些以冒号开头和结尾，并包含表情符号的名称。表情简码表

2.14 任务列表

要创建任务列表，需要在任务列表项之前添加破折号-和方括号[ ]，并在[ ]前面加上空格。要选择一个复选框，请在方括号[]里面添加 x即可。

- [x] Write the press release
- [ ] Update the website
- [ ] Contact the media

3. 参考资料

Markdown 教程

Git 的使用总结

Sat, 19 Oct 2024 00:00:00 GMT

1. 前言

自己在平时的学习中，Git是使用比较多的工具，但是有一些命令常常忘记，或是对一些命令理解不透彻，这里做一个总结和记录。

2. Git简介

这里长话短说，Git是目前世界上最先进的分布式版本控制系统，Git 采用分布式架构，在 Git 中每个开发人员的代码工作副本也是一个可以包含所有变更完整历史记录的存储库。

每当你在Git中提交更新或保存项目状态时，它基本上就会对当时的全部文件创建一个快照并保存这个快照的索引。为了效率，如果文件没有修改，Git 不再重新存储该文件，而是只保留一个链接指向之前存储的文件。 Git 对待数据更像是一个 快照流。如图

你执行的 Git 操作，几乎只往 Git 数据库中添加数据。你很难使用 Git 从数据库中删除数据，也就是说 Git 几乎不会执行任何可能导致文件不可恢复的操作。

3. 基本知识

3.1 版本管理

Git 有三种状态：

已修改(modified)： 表示修改了文件，但还没保存到数据库中。
已暂存(staged)： 表示对一个已修改文件的当前版本做了标记，使之包含在下次提交的快照中。
已提交(committed)： 表示数据已经安全地保存在本地数据库中。

Git 项目拥有三个阶段：

工作区：工作区是对项目的某个版本独立提取出来的内容。可以理解为你正在编辑的那些文件就在工作区之中。
暂存区：是一个文件，保存了下次将要提交的文件列表信息。
Git 仓库： Git 用来保存项目的元数据和对象数据库的地方。这是 Git 中最重要的部分，从其它计算机克隆仓库时，复制的就是这里的数据。

基本的 Git 工作流程如下图

即：

在工作区修改文件
将你想要下次提交的更改选择性地暂存，这样只会将更改的部分添加到暂存区。
提交更新，找到暂存区的文件，将快照永久性存储到 Git 目录。

3.2 分支

分支模型是Git的一个重要特性。其实在每次提交时，Git都会包含一个指向父对象的指针（首次提交对象没有父对象），Git的分支，本质上是指向提交对象的可变指针，Git的默认分支名字是master，多次提交后，我们其实已经有一个指向最后那个提交对象的master分支。

HEAD严格来说不是指向提交，而是指向master，master才是指向提交的，所以，HEAD指向的就是当前分支。如图

当我们创建分支时，相当于创建了一个类似于master的指针，如图

如果HEAD指向dev，那么所作出的修改都会提交到dev分支，如图

合并分支相当于修改master的指针指向dev。

4. Git的安装

参考：Windows系统Git安装教程（详解Git安装过程） - 知乎 (zhihu.com)

每次安装完Git时，记得配置用户名和邮件地址。每一个 Git 提交都会使用这些信息，并且会写入到每一次提交中，不可更改。配置命令：

git config --global user.name "John Doe"
git config --global user.email johndoe@example.com

5. 基础的工作流程

5.1 使用Git进行版本管理

5.1.1 获取 Git 仓库

有两种方式：

将尚未进行版本控制的本地目录转换为 Git 仓库。

执行命令
```
git init
```
将创建一个名为 .git 的子目录，这个子目录含有初始化的 Git 仓库中所有的必须文件。

从其它服务器克隆一个已存在的 Git 仓库。

git clone https://github.com/libgit2/libgit2 mylibgit

可以在克隆的时候指定本地仓库名

git clone https://github.com/libgit2/libgit2 mylibgit

可以指定分支

git clone -b master https://github.com/libgit2/libgit2

5.1.2 查看文件的状态

文件会存在两种状态：

已跟踪：已经被纳入版本控制的文件
未跟踪：没有被纳入版本管理的文件

可以使用命令来检查文件处于什么状态

git status

要查看更加详细的信息可以使用

git diff

此命令比较的是工作目录中当前文件和暂存区域快照之间的差异。也就是修改之后还没有暂存起来的变化内容。

5.1.3 添加文件到暂存区

跟踪新文件和或把已跟踪的文件放到暂存区

git add

参数列表：

git add -A：提交所有变化（ -A == --all ）
git add -u：提交被修改（modified）和被删除（deleted）的文件，不包括新文件（new）。（ -u == --update）
git add .：提交新文件（new）和被修改（modified）文件，不包括被删除（deleted）文件
git add <path> ：等同于 git add .

5.1.4 将暂存区内容提交到仓库

提交更新

git commit -m "提交说明"

可以使用以下命令跳过使用暂存区，即会自动把所有已经跟踪过的文件暂存起来一并提交

git commit -a -m "提交说明"

5.1.5 查看提交历史

git log

显示每次提交的差异：

git log -p

只显示最近两次的提交：

git log -2

5.1.6 撤销操作

如果发现漏了文件忘了提交，可以使用命令

git commit --amend

一个示例如下：

git commit -m 'initial commit'
git add forgotten_file
git commit --amend

取消暂存的文件，可以使用命令

git reset <file>...

撤销对文件的修改

git checkout --<file>

`git checkout — <file>` 是一个危险的命令。 你对那个文件在本地的任何修改都会消失——Git 会用最近提交的版本覆盖掉它。

5.1.7 版本回退

命令为

git reset

回退到上一版本：

git reset --hard HEAD^

参数：

--hard：回退到上一个版本已提交状态
--soft：回退到是一个版本未提交的状态
--mixed：回退到上一个版本已添加但为提交的状态

回退到某个版本

git reset --hard 1094a

后面的字符串是版本号，写前几个即可，Git会自动查找。

如果想恢复到新版本，却找不到新版本的commit id时，可以使用git reflog命令，通过查看命令历史来找到新版本提交的commit id。

5.2 Git 分支的使用

5.2.1 查看分支

查看所有分支

git branch

git branch命令会列出所有分支，当前分支前面会标一个*号。

查看远程分支

git branch -r

查看远程和本地分支

git branch -a

5.2.2 创建分支

创建dev分支，然后切换到dev分支：

git checkout -b dev

git checkout命令加上-b参数表示创建并切换，相当于以下两条命令：

git branch dev
git checkout dev

新版本可以使用如下命令来创建和切换分支:

创建并切换到新的dev分支，可以使用：

git switch -c dev

直接切换到已有的master分支，可以使用：

git switch master

5.2.3 合并分支

一种比较简单的情况是，我们在master分支中，创建并切换到dev分支上进行了修改后，如图

然后我们将dev分支合并到master分支上，这时我们需要切换到master分支，执行命令

git merge dev

如果两者没有冲突，很快地就会合并成功了。但如果我们有一个新的feature1分支，master和feature1分支都有了新的提交，并且两者修改了同一地方，如图

这样会产生冲突，必须手动解决冲突后才能合并。Git检测到这种冲突时，它会在冲突的文件中插入冲突标记。

冲突标记通常以<<<<<<<，=======和>>>>>>>开头，并在两个冲突部分的之间有额外的信息。一个示例如下：

<<<<<<< HEAD
这是版本A的修改内容
=======
这是版本B的修改内容
>>>>>>> branchB

我们对其修改后，再进行提交即可，如图

5.2.4 删除分支

git branch -d feature1

5.4 远程仓库的使用

查看已经连接的远程仓库

git remote -v

添加远程仓库

git remote add <shortname> <url>

git remote add origin https://github.com/paulboone/ticgit

之后我们可以在命令行中使用pd代替后面整个URL。

此时我们可以运行git fetch origin命令来获得远程仓库的副本，但是不会自动修改或合并当前的工作，需要将当前分支合并到远程分支。我们可以设置当前分支跟踪远程分支，然后就可以使用git pull命令自动抓取后合并该分支到当前分支。

创建本地分支并跟踪远程分支

git checkout -b <branch-name> origin/<branch-name>

为现有的本地分支设置跟踪远程分支

git branch --set-upstream-to=origin/<branch-name> <branch-name>

如果当前处于该分支，可以省略本地分支名

git branch --set-upstream-to=origin/<branch-name>

如果仓库是使用git clone得到的，该命令会自动设置本地master分支跟踪克隆远程仓库的master分支。

6 .gitignore文件的编写

.gitignore文件用来告诉 Git 哪些文件或目录不应该被跟踪或提交到版本库中。

忽略文件或目录的基本规则
1. 忽略某个文件，直接写文件名称
```
myfile.txt
```
2. 忽略某个目录，在目录名称后面加/
```
logs/
```
3. 忽略特定类型的文件，使用通配符*来忽略某种类型的文件
```
*.log
```
忽略某个文件夹下的所有文件
```
folder_name/*
```
例外规则

如果你想忽略大多数文件，但保留其中某些文件，可以使用 ! 进行例外。
```
*.log      # 忽略所有 .log 文件
!important.log  # 但不忽略 important.log
```
通配符的使用
1. *：匹配任意数量的字符。例如，忽略所有 .tmp 文件
```
*.tmp
```
2. ?：匹配任意单个字符。例如，忽略 file1.txt, file2.txt, 但不忽略 file11.txt
```
file?.txt
```
3. **：匹配任意层级的目录。例如，忽略所有 tmp 目录下的文件，不论层级
```
tmp/**/*
```
忽略指定目录中特定文件类型
```
logs/*.log
```

注意：即使文件被添加到 .gitignore 中，但它们之前已经被 Git 跟踪，这时需要先停止追踪
git rm --cached <file>

7. 配置git的ssh key

确保用户名和邮箱已经配置

git config --global  --list

如未配置，则执行以下命令

git config --global  user.name "这里换上你的用户名"
git config --global user.email "这里换上你的邮箱"

生成公钥

ssh-keygen -t rsa -C "这里换上你的邮箱"

执行命令后需要进行3次或4次确认：

确认秘钥的保存路径（如果不需要改路径则直接回车）；
如果上一步置顶的保存路径下已经有秘钥文件，则需要确认是否覆盖（如果之前的秘钥不再需要则直接回车覆盖，如需要则手动拷贝到其他目录后再覆盖）；
创建密码（如果不需要密码则直接回车）；
确认密码；

找到生成的公钥文件，windows下一般在目录C:\Users\用户名\.ssh\id_rsa.pub，Linux一般在~/.ssh/id_rsa.pub，打开复制内容

然后打开GitHub，进入设置页面，点击“SSH and GPG keys”，粘贴刚才复制的内容，生成私钥，大功告成。

8. 参考资料

9. 结语

若有其它新内容，后续再补充。

通过 Cloudflare 免费加速个人网站

Sat, 12 Oct 2024 00:00:00 GMT

1. 前言

在搭建博客的过程中，发现网站访问的速度有些慢，便参考了网上的许多教程和博客，并成功使用了Cloudflare 来加速我的博客网站，因此特地写了一篇blog来总结一下。

2. 前置知识

2.1 Cloudflare

Cloudflare（Cloudflare, Inc.）是一家总部位于旧金山的美国跨国科技企业，以向客户提供基于反向代理的内容分发网络（Content Delivery Network, CDN）及分布式域名解析服务（Distributed Domain Name Server）为主要业务。Cloudflare 已经成为互联网上运行的最大网络之一。

Cloudflare的优势有：

DDoS保护：过滤恶意流量，保护网站免受分布式拒绝服务的攻击。
内容分发网络（CDN）：帮助加速网站内容在全球范围内的传输。
SSL/TLS加密安全保护：帮助保护网站和访问者的安全。
提升网页访问速度：通过压缩代码、压缩资源和缓存内容来优化网站性能。
详细流量分析和报告：包括请求、带宽使用和安全事件等信息。
简单直观的界面：易于使用的管理网站设置和配置。
免费和收费计划：可以是获得CDN、DDoS保护和安全等优势的经济实惠方式。
更重要的是有中文的控制面板🫣

2.2 CDN是什么

我们主要是使用Cloudflare的CDN服务进行加速，那么CDN到底是什么呢？

CDN (Content Delivery Network或Content Distribution Network)是一个互连服务器网络，可加快数据密集型应用程序的网页加载速度。CDN 可以表示内容分发网络或内容分配网络。当用户访问某个网站时，来自该网站服务器的数据必须通过互联网传输到用户的计算机。如果用户距离该服务器较远，则加载大文件（例如视频或网站图像）将需要很长时间。相反，如果网站内容存储在距离用户较近的 CDN 服务器上，就可以更快到达他们的计算机。

3. 操作流程

3.1 配置服务

首先你需要一个私有域名，没有可先去注册：

然后登录Cloudflare，没有账号先注册账号。进入的面板如图：

我们输入我们的私有域名，点击继续，然后选择免费的计划

注意：不要填带有www.域名

点击继续，我们可以看到如下界面

3.2 按照下方的快速入门指南进行配置

一律保存即可。

3.3 更改DNS服务器

先在Cloudflare中找到给我们分配的DNS服务器，如图

接下来需要到我们的服务器商那里更换我们域名的DNS服务器，以阿里云为例，进入域名控制台 (aliyun.com)，找到我们需要加速的域名

点击管理

在DNS修改中，输入刚才复制的域名

等待一段时间后，会收到Cloudflare发来的邮件

这里每个人的等待时间不一样，请耐心等待

成功后，界面变成如图所示

到此我们已经可以使用Cloudflare进行CDN加速了，我们还可以进行其他配置。

3.4 其他配置

将SSL/TLS设置成完全（严格），增加网页安全性。
启用 Always Online 后，即使你源服务器一时瘫痪，也会显示 Cloudflare 创建好的网站副本。这样就可以始终向访问者提供信息。

4. 参考资料

Cloudflare设置流程免费CDN加速你的网站【2024年最新】

我的第一篇博客

Thu, 10 Oct 2024 00:00:00 GMT

你好，欢迎来到我的博客！

拥有一个属于自己的博客一直是我小小的愿望，尽管之前由于时间问题我多次推迟了动笔的计划，现在终于迈出了这一步了。希望通过这个博客，不仅能积累和分享技术知识，还能记录自己的学习和成长轨迹，遇见更多志同道合的你们。

关于我

目前就读于中山大学通信工程专业，对编程和技术有浓厚的兴趣，喜欢探索新领域。无论是前端还是后端，硬件还是软件，EE还是CS，都有一定的了解，目前正在探索自己感兴趣的方向。

为什么选择写博客

这个想法由来已久，加上受到一位朋友的启发，意识到写博客不仅是整理思路、总结经验的好方法，还能帮助那些有类似经历的人。因此，我决定搭建属于自己的博客，既是实现自己的目标，也是记录成长的过程。在这里，我会分享技术文章、学习经验以及一些生活中的思考。

希望分享的内容

未来，我会分享学习中的心得体会、问题解决的技巧，甚至是失败的教训。同时，也会涉及一些生活和个人成长的内容，让博客更加丰富。无论你是对技术感兴趣，还是寻找学习启发的伙伴，我都期待与你在这里交流。

一起前行

写博客对我来说都是全新的挑战。如果你有任何建议或想法，欢迎随时留言，我们可以一起讨论、共同进步。

感谢你的到访，希望你能在这里找到感兴趣的内容！

liangbm3's blog

Debug 记录：一个缺失的“\0”和一个意外的“%”引发的挂死

1. 案发现场

2. 代码回溯

3. 根因分析

3.1 第一环：缺失的终止符 \0

3.2 第二环：日志函数的“二次格式化”漏洞

3.3 第三环：致命的 %n

4. 意外发现

5. 问题修复

6. 总结

Effective C++: 避免遮掩继承而来的名称

Effective C++: 确定你的 public 继承塑模出 is-a 关系

Effective C++: 成对使用 new 和 delete 时要采取相同形式

Effective C++: 以独立语句将 newed 对象置入智能指针

Effective C++: 在资源管理类中提供对原始资源的访问

Effective C++: 以对象管理资源

Effective C++: 在资源管理类中小心 copying 行为

Effective C++: 为多态基类声明虚析构函数

Effective C++: 视C++为一个语言联邦

C++ 中使用 SQLite3 API 的经典流程

1. 核心概念

2. 经典使用流程

2.1 包含头文件和定义必要变量

2.2 打开或创建数据库

2.3 执行SQL语句（非查询类）

2.4 执行查询并处理结果

2.4.1 准备SQL语句

2.4.2 绑定参数

2.4.3 执行语句并逐行获取结果

2.5 销毁语句句柄

2.6 关闭数据库

3. 总结

SQLite 踩坑记录

1. 问题背景

2. 问题根源

3. 总结

4. 拓展

单源最短路径

1. 简介

2. Dijkstra 算法

3. Bellman-Ford 算法

4. SPFA 算法

并查集

1. 简介

2. 实现

2.1 Quick Find

2.2 Quick Union

2.3 路径压缩

2.4 按秩合并/按大小合并

最小生成树

1. 简介

2. 应用场景

3. 经典算法

3.1 Kruskal 算法

3.2 Prim 算法

堆及其相关应用

1. 堆简介

2. 堆的存储

3. 堆的操作

3.1 插入上浮

3.2 删除下沉

4. 堆的构建

4.1 逐个插入法

4.2 原地建堆法

6. 优先队列

6.1 简介

6.2 应用场景

6.3 实现

6.4 C++ 中的优先队列

拓扑排序

1. 拓扑排序简介

2. 算法及实现

2.1 Kahn 算法

2.2 DFS 算法

3. 复杂度分析

C++ 中静态局部变量的使用场景

1. 函数调用计数器

2. 实现缓存

3. 在递归中保持状态

3.1 第一环：缺失的终止符 `\0`

3.3 第三环：致命的 `%n`

3. `static`

4. `extern`

4.2 `std::bind`

1. `sizeof`运算符简介

2. `sizeof`运算符的常见用法

3. `sizeof`运算符的一些特性

4. `sizeof`的其他常见问题