Galileo

C++ 指针入门：地址、解引用与内存访问

Sun, 17 May 2026 00:00:00 GMT

本文是 C++ 系列的第二篇。

上一篇：C++ 系列前言：从语法到工程能力

指针是 C++ 里最容易被低估的基础概念之一。

表面上看，指针只是“保存地址的变量”。但一旦把它放进实际代码，就会继续牵出对象、类型、解引用、数组、函数参数、生命周期和未定义行为。

本文先不讨论动态内存和智能指针，只关注最小模型：

变量有值，也有地址
指针变量保存某个对象的地址
解引用可以通过地址访问对象
指针类型决定如何解释那块内存
只有指向有效对象的指针才能被解引用

1. 变量、对象和地址

在 C++ 里，一个普通变量至少包含几层信息：

变量名：代码中访问它的名字
类型：决定这块数据应该按什么格式解释
值：当前保存的数据
地址：对象在内存中的位置

看一个最小例子：

#include <iostream>

int main() {
    int a = 10;

    std::cout << "a  = " << a << '\n';
    std::cout << "&a = " << &a << '\n';

    return 0;
}

一次可能的运行结果：

a  = 10
&a = 0x16b7fad4c

这里：

a 表示变量的值，也就是 10
&a 表示对变量 a 取地址

地址每次运行都可能不同，这和栈布局、地址空间随机化等因素有关。理解指针时不需要记住某个具体地址，只需要记住：变量除了有值，也有对应的存储位置。

从语言层面看，&a 的结果类型是 int*，意思是“指向 int 对象的指针”。

2. 指针是保存地址的变量

指针本身也是变量。

普通 int 变量保存整数，double 变量保存浮点数，而指针变量保存的是地址。

#include <iostream>

int main() {
    int a = 10;
    int* p = &a;

    std::cout << "a  = " << a << '\n';
    std::cout << "&a = " << &a << '\n';
    std::cout << "p  = " << p << '\n';
    std::cout << "*p = " << *p << '\n';

    return 0;
}

一次可能的运行结果：

a  = 10
&a = 0x16d7dad4c
p  = 0x16d7dad4c
*p = 10

这段代码里最关键的是：

int* p = &a;

它可以拆成两部分理解：

int*：p 是一个指针，指向的对象类型是 int
&a：取出 a 的地址，并把这个地址保存到 p 里

所以：

p 的值等于 &a
*p 表示沿着 p 保存的地址访问对应对象
因为 p 指向 a，所以 *p 读到的就是 a 的值

需要注意声明写法：

int* p1, p2;

这行里只有 p1 是 int*，p2 是普通 int。如果要声明两个指针，应该写成：

int* p1;
int* p2;

或者：

int *p1, *p2;

更推荐每行只声明一个变量，避免在指针声明上制造歧义。

3. 解引用：通过地址访问对象

*p 叫解引用。

如果 p 保存了某个有效对象的地址，那么 *p 就表示那个对象本身。

这意味着我们不仅可以通过指针读取变量，也可以通过指针修改变量。

#include <iostream>

int main() {
    int a = 10;
    int* p = &a;

    *p = 20;

    std::cout << "a  = " << a << '\n';
    std::cout << "*p = " << *p << '\n';

    return 0;
}

运行结果：

a  = 20
*p = 20

关键点在这里：

*p = 20;

这不是修改 p 这个指针变量本身，而是修改 p 指向的对象。

可以把两种赋值分开看：

p = &a;   // 修改指针变量 p 保存的地址
*p = 20;  // 修改 p 指向的对象

这是理解指针时最重要的分界线：

p 是指针变量
*p 是指针指向的对象
&p 是指针变量自己的地址

4. 指针自己也有地址

因为指针也是变量，所以指针自己也需要存储空间，也有自己的地址。

#include <iostream>

int main() {
    int a = 10;
    int* p = &a;

    std::cout << "&a = " << &a << '\n';
    std::cout << "p  = " << p << '\n';
    std::cout << "&p = " << &p << '\n';

    return 0;
}

一次可能的运行结果：

&a = 0x16b5dad4c
p  = 0x16b5dad4c
&p = 0x16b5dad40

这里有两层地址：

p 的值是 a 的地址
&p 是指针变量 p 自己的地址

所以 p 和 &p 不是一回事。

如果继续取地址，&p 的类型是 int**，也就是“指向 int* 的指针”。这就是二级指针的来源，后面遇到函数修改指针本身、二维数组、命令行参数时还会继续用到。

5. 指针类型为什么重要

指针保存的是地址，但 C++ 里的指针不只是一个裸地址。

指针类型至少影响两件事：

解引用时，编译器应该按什么类型解释这块内存
指针运算时，地址应该按多大步长移动

先看数组和指针加法：

#include <iostream>

int main() {
    int arr[3] = {10, 20, 30};
    int* p = arr;

    std::cout << "p           = " << p << '\n';
    std::cout << "p + 1       = " << p + 1 << '\n';
    std::cout << "*p          = " << *p << '\n';
    std::cout << "*(p + 1)    = " << *(p + 1) << '\n';
    std::cout << "sizeof(int) = " << sizeof(int) << '\n';

    return 0;
}

一次可能的运行结果：

p           = 0x16f9dad40
p + 1       = 0x16f9dad44
*p          = 10
*(p + 1)    = 20
sizeof(int) = 4

如果 int 占 4 个字节，那么 p + 1 不是让地址数值加 1，而是移动到下一个 int 的位置，也就是向后移动 4 个字节。

这就是指针类型的作用：

int* p;

表示 p 指向的是 int，所以：

*p 会按 int 读取或写入
p + 1 会移动 sizeof(int) 个字节

如果是：

double* q;

那么 q + 1 会移动 sizeof(double) 个字节。

顺便注意一件事：在大多数表达式里，数组名 arr 会转换成指向首元素的指针，也就是 &arr[0]。所以下面两行在这个例子里效果相同：

int* p1 = arr;
int* p2 = &arr[0];

但数组本身和指针不是同一种类型，后面讲数组、函数参数和 sizeof 时需要单独区分。

6. `nullptr`：明确表示“不指向对象”

如果一个指针暂时不指向任何有效对象，应该初始化为 nullptr。

#include <iostream>

int main() {
    int* p = nullptr;

    if (p == nullptr) {
        std::cout << "p does not point to anything now\n";
    }

    return 0;
}

nullptr 表示空指针，它不指向任何有效对象。

所以不能对空指针解引用：

int* p = nullptr;

// 错误示范：未定义行为
std::cout << *p << '\n';

对空指针解引用是未定义行为。程序可能崩溃，也可能表现出别的异常现象，不能依赖任何结果。

在现代 C++ 里，优先使用 nullptr，不要继续使用 NULL 或 0 表示空指针。nullptr 有独立类型 std::nullptr_t，在重载解析等场景下更清晰。

7. 指针作为函数参数

指针常见用途之一，是把对象地址传给函数。

如果函数拿到的是值，它修改的是副本：

#include <iostream>

void changeByValue(int x) {
    x = 100;
}

int main() {
    int a = 10;

    changeByValue(a);

    std::cout << "a = " << a << '\n';

    return 0;
}

运行结果：

a = 10

如果函数拿到的是指针，它就可以通过地址修改调用者传入的对象：

#include <iostream>

void changeByPointer(int* p) {
    if (p == nullptr) {
        return;
    }

    *p = 100;
}

int main() {
    int a = 10;

    changeByPointer(&a);

    std::cout << "a = " << a << '\n';

    return 0;
}

运行结果：

a = 100

这里传进去的是 a 的地址。函数内部执行 *p = 100; 时，修改的是外面的 a。

从接口设计角度看，指针参数通常表达两层含义：

函数可能通过这个参数访问或修改外部对象
这个参数可能为空，因此函数需要考虑 nullptr

如果函数要求参数一定存在，而且只是想直接操作对象，很多时候引用会更合适：

void changeByReference(int& x) {
    x = 100;
}

简单规则是：可以为空时用指针，必须存在时优先考虑引用。当然，具体选择还要结合接口语义和已有代码风格。

8. 常见错误

8.1 未初始化指针

int* p;

// 错误示范：p 没有被初始化
*p = 10;

局部指针变量如果没有初始化，它的值是不确定的。此时直接解引用，程序会访问一个不可预期的地址，属于未定义行为。

如果暂时不知道它应该指向谁，先写成：

int* p = nullptr;

8.2 空指针解引用

int* p = nullptr;

// 错误示范：nullptr 不指向有效对象
std::cout << *p << '\n';

nullptr 的作用是表达“当前没有指向对象”，不是提供一个可以访问的默认对象。

使用可能为空的指针前，先判断：

if (p != nullptr) {
    std::cout << *p << '\n';
}

8.3 悬空指针

#include <iostream>

int main() {
    int* p = nullptr;

    {
        int a = 10;
        p = &a;
    }

    // 错误示范：a 的生命周期已经结束
    std::cout << *p << '\n';

    return 0;
}

a 是代码块里的局部变量。代码块结束后，a 的生命周期结束，p 仍然保存原来的地址，但那个地址上已经没有一个有效的 int a 对象。

这种指针叫悬空指针。

悬空指针最危险的地方在于：它的值看起来仍然像一个地址，但这个地址已经不能再按原来的对象使用。

8.4 越界指针访问

int arr[3] = {10, 20, 30};
int* p = arr;

// 错误示范：越过数组有效元素
std::cout << *(p + 3) << '\n';

对于长度为 3 的数组，合法元素是：

arr[0], arr[1], arr[2]

p + 3 可以作为“尾后位置”参与比较，但不能解引用。

int* begin = arr;
int* end = arr + 3;

for (int* it = begin; it != end; ++it) {
    std::cout << *it << '\n';
}

这里 end 表示范围结束位置，只作为边界，不作为可访问元素。

9. 小结

这一篇先记住这些规则：

&a 表示取出变量 a 的地址
int* p = &a; 表示 p 保存一个 int 对象的地址
p 是指针变量本身，*p 是指针指向的对象，&p 是指针变量自己的地址
指针类型决定解引用方式，也决定 p + 1 移动多少字节
未初始化指针、空指针、悬空指针都不能解引用
指针参数常用来表达“函数可能访问或修改外部对象”，也可能表达“这个参数允许为空”

理解指针的关键不是背概念，而是把每个符号对应到明确含义上：

int a = 10;
int* p = &a;

p;   // 保存的地址
*p;  // 地址指向的 int 对象
&p;  // 指针变量 p 自己的地址

后面再看引用、数组、动态内存、对象生命周期、智能指针和迭代器失效，都会不断回到这几个基本问题：这个对象在哪里，谁保存了它的地址，它现在是否还有效。

C++ 系列前言：从语法到工程能力

Fri, 15 May 2026 00:00:00 GMT

C++ 系列前言：从语法到工程能力

1. 为什么重新整理 C++

C++ 不是一门只靠记语法就能写好的语言。

写出 for、class、vector 并不难，真正容易出问题的是这些代码背后的运行机制：对象什么时候创建和销毁，指针保存的地址是否仍然有效，拷贝发生在什么地方，容器扩容会不会让迭代器失效，编译器为什么能通过声明找到定义。

这些问题平时看起来分散，但在实际工程里经常同时出现。一个程序崩溃，可能不是算法写错了，而是访问了已经失效的对象；一个链接错误，可能不是代码逻辑问题，而是声明、定义和编译单元之间的关系没有处理好。

所以这个系列的重点不是把 C++ 语法列表重新讲一遍，而是把常见概念放回程序运行和工程开发的上下文中理解。

2. 这个系列想解决什么问题

这个系列的目标，是把“能写一点 C++ 代码”逐步推进到“能解释代码行为，并写出更可靠的 C++ 代码”。

我会重点关注几个方向：

类型与对象：变量、对象、地址、生命周期、值类别等基础概念
指针与引用：内存访问、解引用、空指针、悬空指针、函数参数传递
资源管理：构造析构、拷贝控制、移动语义、RAII、智能指针
STL 使用：容器、迭代器、算法、扩容、失效规则和性能取舍
工程工具：头文件、源文件、编译链接、CMake、gdb、库文件
小项目实践：把零散概念放到一个可运行、可调试、可维护的项目里验证

这不是一套“高手教程”，更像是一份逐步补全 C++ 基本功的技术笔记。

3. 写作方式

每篇文章会尽量采用同一套结构：

先说明要解决的具体问题
给出一段足够小的 C++ 示例
展示可能的运行结果或编译错误
解释现象背后的语言规则
总结容易踩坑的地方
给出当前阶段可以记住的判断规则

这样写的原因很简单：C++ 里的很多概念只看定义很容易产生错觉，必须通过代码、输出和错误信息反复验证。

例如“指针保存地址”这句话很短，但真正写代码时还会继续遇到：

指针本身也有地址
指针类型会影响解引用方式
指针加法不是普通整数加法
空指针和悬空指针都不能解引用
函数拿到指针后可能修改调用者的对象

把这些细节拆开验证，理解会更稳。

4. 暂定目录

目录会随着学习进度调整，但整体路线先按“基础概念 -> 对象与内存 -> STL -> 工程工具 -> 小项目实践”推进。

第一部分：C++ 基础概念

变量、地址和指针
指针和引用的差异
const 到底修饰谁
栈、堆和对象生命周期
new/delete 和 malloc/free 的区别

第二部分：对象与内存管理

构造函数和析构函数什么时候执行
浅拷贝和深拷贝为什么危险
拷贝构造函数和赋值运算符有什么区别
为什么基类析构函数有时要写成 virtual
this 指针到底是什么

第三部分：STL 与常用容器

vector 为什么会自动扩容
vector 和 list 应该怎么选
map 和 unordered_map 的区别
迭代器失效是什么问题
push_back 和 emplace_back 的区别

第四部分：编译、调试与工程工具

C++ 项目为什么要分 .h 和 .cpp
一个 C++ 程序从 .cpp 到可执行文件经历了什么
使用 CMake 管理一个最小 C++ 项目
用 gdb 定位一次段错误
静态库和动态库的区别

第五部分：小项目实践

用 C++ 写一个命令行小工具
从零写一个简单日志系统
线程池解决了什么问题
从零写一个最小线程池
一个 C++ 小项目的完整复盘

5. 需要先建立的几个判断

后面的文章会反复围绕几个判断展开。

第一，C++ 代码是否正确，不能只看“能不能编译过”。编译通过只能说明语法和类型检查没有发现问题，不代表运行时访问的内存一定有效。

第二，资源的所有权必须说清楚。谁创建对象，谁负责释放资源，谁只是临时观察对象，这些关系如果不明确，后面就很容易出现泄漏、重复释放或悬空访问。

第三，工具链也是 C++ 学习的一部分。编译错误、链接错误、运行时崩溃和调试信息，都是理解程序行为的重要入口。

第四，C++ 的复杂性需要用约束来管理。能用标准库就不要手写底层结构；能用 RAII 就不要手动管理释放；能让生命周期清晰，就不要把裸指针到处传。

6. 从哪里开始

这个系列从指针开始。

指针是 C++ 里最基础也最容易误解的概念之一。它连接了变量、地址、内存访问、数组、动态分配、函数参数、对象生命周期等很多内容。

理解指针不等于以后处处使用裸指针，但如果完全绕开指针，就很难真正理解 C++ 为什么会有空指针、悬空指针、迭代器失效、智能指针和 RAII。

后面的文章会从最小示例开始，一步一步把这些概念补起来。

C++ 系列

Fri, 15 May 2026 00:00:00 GMT

这个系列整理 C++ 相关内容，重点不只是“语法怎么写”，而是理解代码背后的运行机制：对象如何存储，指针和引用如何访问内存，资源生命周期如何管理，程序如何经过编译链接变成可执行文件。

文章会尽量采用固定结构：先给出问题，再用最小代码复现现象，观察运行结果，最后解释原因和常见错误。

系列目录

Linux系统

Mon, 11 May 2026 00:00:00 GMT

这个系列记录 Linux 系统使用、命令行操作和环境配置相关内容。

系列目录

Linux常用指令入门

Mon, 11 May 2026 00:00:00 GMT

最近在和我一个学长做项目。因为十分贫穷，加上校内服务器十分堵塞，压根排不到我们，最后我们决定上网租服务器（虽然发现这个决策使得我们的钱包更加不饱满）。这个时候发现学长并不熟悉 Linux 的一些常用指令，这也启发我给自己的 blog 加上一篇关于常用指令的推文。

Linux 的很多操作都可以通过命令行完成。刚开始接触时，不需要一次性记住所有命令，先掌握目录切换、文件操作、文件内容查看、权限管理和进程查看这几类常用指令，就可以完成大部分日常工作。

本文记录一些入门阶段最常用的 Linux 指令，方便之后查阅。

1. 查看当前所在位置

pwd

pwd 会显示当前终端所在的目录路径。例如：

/home/user/project

当你不知道自己现在在哪个文件夹时，可以先运行这个命令。

2. 查看目录内容

ls

常见用法：

ls          # 查看当前目录下的文件
ls -l       # 以详细列表形式显示
ls -a       # 显示隐藏文件
ls -lh      # 以更易读的大小单位显示

在 Linux 中，以 . 开头的文件或目录是隐藏文件，例如 .git、.bashrc。

3. 切换目录

cd 目录名

常见用法：

cd /home/user       # 切换到指定绝对路径
cd project          # 进入当前目录下的 project 文件夹
cd ..               # 返回上一级目录
cd ~                # 回到当前用户的家目录
cd -                # 回到上一次所在目录

绝对路径从 / 开始，相对路径从当前目录开始。

4. 创建文件和目录

创建目录：

mkdir notes

递归创建多级目录：

mkdir -p projects/linux/test

创建空文件：

touch hello.txt

touch 如果遇到不存在的文件，会创建它；如果文件已经存在，会更新它的修改时间。

5. 复制、移动和重命名

复制文件：

cp source.txt target.txt

复制目录：

cp -r old_dir new_dir

移动文件：

mv file.txt /tmp/

重命名文件：

mv old_name.txt new_name.txt

mv 既可以移动文件，也可以重命名文件，具体取决于目标路径。

6. 删除文件和目录

删除文件：

rm file.txt

删除目录：

rm -r folder

强制删除：

rm -rf folder

rm -rf 很危险，它不会进入回收站，执行前一定要确认路径是否正确。

7. 查看文件内容

一次性输出文件内容：

cat file.txt

分页查看长文件：

less file.txt

查看文件开头：

head file.txt
head -n 20 file.txt

查看文件末尾：

tail file.txt
tail -n 20 file.txt

实时查看日志：

tail -f app.log

查看程序日志时，tail -f 非常常用。

8. 搜索文件内容

grep "keyword" file.txt

常见用法：

grep "error" app.log
grep -n "error" app.log        # 显示行号
grep -i "error" app.log        # 忽略大小写
grep -r "TODO" .               # 在当前目录递归搜索

如果只记一个搜索命令，先记住 grep -r "关键词" .。

9. 查找文件

按文件名查找：

find . -name "*.md"

查找当前目录下所有 Markdown 文件：

find . -type f -name "*.md"

查找目录：

find . -type d -name "build"

find 的第一个参数表示从哪里开始找，. 表示当前目录。

10. 查看磁盘和文件大小

查看磁盘空间：

df -h

du -sh *

查看某个目录总大小：

du -sh folder

其中 -h 表示 human-readable，会用 KB、MB、GB 这种更容易理解的单位显示。

11. 查看和结束进程

查看当前用户的进程：

ps

查看所有进程：

ps aux

动态查看系统资源：

top

结束某个进程：

kill PID

如果进程无法正常结束，可以使用：

kill -9 PID

PID 是进程编号，可以通过 ps aux 或 top 找到。

12. 权限相关命令

查看权限：

ls -l

给脚本添加可执行权限：

chmod +x script.sh

修改文件拥有者：

sudo chown user:user file.txt

sudo 表示用管理员权限执行命令。使用 sudo 前要确认命令确实需要更高权限。

13. 压缩和解压

打包并压缩：

tar -czvf archive.tar.gz folder

解压：

tar -xzvf archive.tar.gz

常见参数含义：

c: create，创建压缩包
x: extract，解压
z: 使用 gzip
v: 显示过程
f: 指定文件名

14. 网络相关命令

测试网络连通：

ping github.com

下载文件：

curl -O https://example.com/file.zip

查看当前机器 IP：

ip addr

在 macOS 上，类似命令是：

ifconfig

15. 常用组合

进入目录并查看内容：

cd project
ls -lh

查找日志中的错误：

grep -n "error" app.log

查看某个目录大小：

du -sh .

查看最近的日志输出：

tail -f app.log

查找当前目录下所有 Python 文件：

find . -type f -name "*.py"

总结

Linux 命令入门可以先按使用场景记忆：

位置和目录：pwd、ls、cd
文件操作：mkdir、touch、cp、mv、rm
内容查看：cat、less、head、tail
搜索查找：grep、find
系统状态：df、du、ps、top
权限管理：chmod、chown、sudo

这些命令不需要死记硬背，最好的方式是在真实项目和日常操作里反复使用。

EKF 算法详解：(一) 简介与基础

Thu, 12 Mar 2026 00:00:00 GMT

本文是 EKF 算法详解系列的第一篇。

下一篇：EKF 算法详解：(二) 姿态解算与数学推导

在机器人、自动驾驶、无人机等领域中，“状态估计”是一个绕不开的核心问题。无论是云台的姿态解算，还是车辆的轨迹跟踪，我们都希望知道系统在当前时刻的准确状态。而在众多状态估计算法中，扩展卡尔曼滤波（Extended Kalman Filter, 简称 EKF） 无疑是最经典、应用最广泛的算法之一。

本系列文章将带你从零开始，理解 EKF 算法。本文为第一篇，主要介绍 EKF 的基本概念、它与标准卡尔曼滤波的区别，以及它的核心思想。

1. 什么是卡尔曼滤波 (Kalman Filter)?

在介绍 EKF 之前，我们需要先简单回顾一下标准卡尔曼滤波 (KF)。

在现实世界中，任何传感器都有噪声（误差），任何物理模型也都无法做到 100% 完美预测。卡尔曼滤波的本质，就是融合“系统模型的预测”与“传感器的实际测量”，通过数学推导，找出一个在统计意义上“最靠谱”的最优估计值。

卡尔曼滤波主要分为两个不断循环的步骤：

预测 (Predict)：根据上一时刻的状态和物理模型（如运动学方程：位移 = 速度 × 时间），推算出当前时刻的“先验状态”。
更新 (Update)：读取传感器的测量值，计算测量值与预测值之间的差异（残差），然后通过“卡尔曼增益”来动态决定是更相信模型预测，还是更相信传感器测量，最终得到当前时刻的“后验状态”。

标准 KF 的局限性

标准卡尔曼滤波有一个致命的假设前提：系统必须是线性的。也就是说，状态的转移和观测过程都必须能用线性矩阵相乘来表示。但在真实世界里，比如角度的旋转涉及正弦/余弦运算（如欧拉角、四元数），或者是复杂的阻力模型，这些都是非线性的。这时候，标准 KF 就会失效。

2. 为什么需要扩展卡尔曼滤波 (EKF)?

既然现实系统大多是非线性的，我们就需要对标准卡尔曼滤波进行“扩展”——这就是 EKF 诞生的原因。

EKF 的核心思想非常简单粗暴但又极其有效：既然系统是非线性的，那就在当前工作点附近把它“局部线性化”。

具体来说，EKF 利用了高等数学中的泰勒展开（Taylor Expansion）。它将非线性的状态转移函数和观测函数在当前的最优估计值处进行一阶泰勒展开，忽略掉高阶项。这样一来，复杂的非线性函数就被近似成了一个线性模型（即求导数，得到雅可比矩阵 Jacobian）。

EKF 的优势：

适用性广：完美解决了非线性系统的状态估计问题（例如机器人的视觉位姿追踪）。
计算效率高：相比于粒子滤波（PF）或无迹卡尔曼滤波（UKF），EKF 只需要计算一阶雅可比矩阵，计算量较小，非常适合部署在算力受限的嵌入式设备（如各类单片机、STM32 等）上。

3. EKF 算法的通用五步公式

一个标准的 EKF 同样遵循“预测”和“更新”两大阶段，具体的数学公式通常被归纳为以下经典的五步：

预测阶段 (Predict)

状态预测：根据非线性运动方程推算先验状态。 $$ \hat{x}k^- = f(\hat{x}{k-1}, u_{k-1}) $$
协方差预测：通过状态转移的雅可比矩阵 ( F )，更新预测误差协方差矩阵。 $$ P_k^- = F P_{k-1} F^T + Q $$

更新阶段 (Update)

计算卡尔曼增益：利用观测模型的雅可比矩阵 ( H ) 计算增益 ( K )。 $$ K_k = P_k^- H^T (H P_k^- H^T + R)^{-1} $$
状态更新：根据传感器实际测量值 ( z_k ) 与预测值的残差，修正状态，得到后验最优估计。 $$ \hat{x}_k = \hat{x}_k^- + K_k (z_k - h(\hat{x}_k^-)) $$
协方差更新：降低不确定度，更新协方差矩阵供下一轮使用。 $$ P_k = (I - K_k H) P_k^- $$

(注：这里的 ( Q ) 是过程噪声协方差，( R ) 是测量噪声协方差，它们通常在实际工程中作为“超参数”根据经验进行调参。)

4. 结语与预告

EKF 虽然在数学表达上看起来有些劝退，但只要理解了它**“线性化”与“加权融合”**的核心思想，就能在工程中游刃有余。

在许多实际开源项目（如 RoboMaster 的视觉算法）中，EKF 常被用于追踪装甲板的运动或云台的姿态。在处理三维空间的旋转时，我们为了避免“万向节死锁”和保持约束，通常会引入四元数与误差状态 (Error-State)。

在下一篇文章中，我们将直接进入硬核部分：结合机器人的视觉姿态解算场景，详细推导基于四元数和误差状态的 EKF 数学模型！

EKF 算法详解：(二) 姿态解算与数学推导

Thu, 12 Mar 2026 00:00:00 GMT

本文是 EKF 算法详解系列的第二篇。

上一篇：EKF 算法详解：(一) 简介与基础 | 下一篇：EKF 算法详解：(三) 源码解析实现

在实际的机器人（如 RoboMaster）视觉和云台控制中，扩展卡尔曼滤波（EKF）经常被用于姿态解算（Attitude Estimation）。在本篇文章中，我们将结合实际项目中的四元数（Quaternion）状态，深入推导 EKF 的核心数学模型。

1. 为什么使用四元数与误差状态？

在三维空间中表示旋转，欧拉角容易遇到“万向节死锁”问题，旋转矩阵则需要维护 9 个元素且保持正交约束。四元数 (Quaternion) 只需要 4 个元素，且计算效率高，是姿态表示的最佳选择。

然而，传统的 EKF 难以直接应用于四元数，因为四元数必须满足单位长度约束（( ||q|| = 1 )）。如果直接对四元数进行线性加减（如 ( q = q + \Delta q )），会破坏其模长。

因此，在实际工程中，我们通常采用 误差状态卡尔曼滤波（Error-State Kalman Filter, ESKF） 或称乘性 EKF（MEKF）：

名义状态 (Nominal State)：用四元数 ( q ) 表示，通过乘法进行更新：( q_{new} = q \otimes \Delta q )
误差状态 (Error State)：用一个三维向量（误差角 ( \delta \theta )）表示，其协方差矩阵 ( P ) 为 3x3 的矩阵。

2. 状态预测方程 (Prediction)

假设我们已知当前的角速度 ( \omega ) 和角加速度 ( \alpha )，在时间间隔 ( \Delta t ) 内，角度的变化量 ( \Delta \theta ) 可以近似表示为： $$ \Delta \theta \approx (\omega + \alpha \cdot \Delta t) \Delta t $$

根据角度变化量 ( \Delta \theta )，我们可以构造出一个微小旋转的四元数更新量 ( q_{update} )。设 ( \theta = ||\Delta \theta|| ) 为旋转角，旋转轴 ( u = \frac{\Delta \theta}{\theta} )：

如果旋转角极小（如 ( \theta < 10^{-6} )），根据泰勒展开，四元数更新量可以近似为： $$ q_{update} \approx \begin{bmatrix} 1 \\ 0.5 \Delta \theta_x \\ 0.5 \Delta \theta_y \\ 0.5 \Delta \theta_z \end{bmatrix} $$
如果角度较大，则严格按照四元数轴角公式： $$ q_{update} = \begin{bmatrix} \cos(\frac{\theta}{2}) \\ u \sin(\frac{\theta}{2}) \end{bmatrix} $$

最终预测的四元数状态为： $$ \hat{q}{k} = q{k-1} \otimes q_{update} $$

3. 雅可比矩阵的计算 (Jacobian)

在误差状态模型中，我们需要计算误差状态相对于角速度和旋转的雅可比矩阵 ( J )（部分实现中作为观测矩阵或状态转移矩阵的近似）。

定义角速度 ( \omega ) 的反对称矩阵（Skew-symmetric matrix）为 ( [\omega]\times )： $$ [\omega]\times = \begin{bmatrix} 0 & -\omega_z & \omega_y \\ \omega_z & 0 & -\omega_x \\ -\omega_y & \omega_x & 0 \end{bmatrix} $$

一阶近似下，误差状态转移的雅可比矩阵可以表示为： $$ J = I_{3\times3} + \frac{1}{2} \Delta t [\omega]_\times $$

4. 状态更新方程 (Update)

当新的测量值（例如视觉 PnP 解算得到的四元数测量值 ( q_{meas} )）到来时，我们需要计算预测值 ( \hat{q}k ) 与测量值的残差（Residual）： $$ q{res} = q_{meas} \otimes \hat{q}k^{-1} $$ 我们提取这个残差四元数的虚部向量部分 ( z{res} = [q_{res}.x, q_{res}.y, q_{res}.z]^T ) 作为测量残差向量。

接着，计算卡尔曼增益 ( K )。假设我们提取的雅可比矩阵为 ( J )，系统误差协方差为 ( P )，测量噪声协方差为 ( R )： $$ K = P J^T (J P J^T + R)^{-1} $$

随后将增益乘上残差，得到误差角度修正量： $$ K_z = K \cdot z_{res} $$

最后，利用这个三维修正量构造误差四元数，乘到预测状态上，并更新协方差矩阵 ( P )： $$ q_{new} = \hat{q}k \otimes \begin{bmatrix} 1 \\ K_z.x \\ K_z.y \\ K_z.z \end{bmatrix} $$ $$ P{new} = (I_{3\times3} - K J) P $$

以上就是一套完整用于姿态跟踪的轻量级 EKF/ESKF 数学推导模型。在下一篇文章中，我们将直接拆解 C++ 落地代码，看看这些公式是如何变成实际运行的程序的！

EKF算法概述

Thu, 12 Mar 2026 00:00:00 GMT

欢迎来到 EKF (扩展卡尔曼滤波) 算法详解系列。本系列将从基础概念出发，逐步深入到复杂的数学推导，并最终通过代码实现一个完整的 EKF 算法。

系列目录

EKF 算法详解：(三) 源码解析实现

Thu, 12 Mar 2026 00:00:00 GMT

本文是 EKF 算法详解系列的第三篇。

上一篇：EKF 算法详解：(二) 姿态解算与数学推导

在上一篇文章中，我们详细推导了基于四元数和误差状态的 EKF 数学模型。理论推导无论多么完美，最终都需要落地成代码。本文我们将结合一个实际项目的源码（基于 C++ 和 Eigen 库），带你一行行看懂 EKF 的实现细节。

1. 类的定义与初始化 (`ekf.hpp`)

在 C++ 中，我们通常会定义一个 ekf 类来维护卡尔曼滤波器的状态和协方差矩阵。这里我们使用开源且极其强大的矩阵运算库 Eigen。

#ifndef TOOLS__EKF_HPP
#define TOOLS__EKF_HPP
#include <Eigen/Geometry>
#include <eigen3/Eigen/src/Geometry/Quaternion.h>
#include <iostream>

namespace tools
{
class ekf
{
public: 
    ekf();
    ~ekf();
    // 预测步骤：根据角速度和角加速度预测下一个四元数状态
    Eigen::Quaterniond predict(const Eigen::Quaterniond &q, const Eigen::Vector3d &omega, const Eigen::Vector3d &alpha, float dt);
  
    // 计算雅可比矩阵
    Eigen::Matrix3d calculate_jacobian(const Eigen::Quaterniond &q, const Eigen::Vector3d &omega, float dt);

    // 核心更新步骤
    void ekf_update(Eigen::Quaterniond &q, const Eigen::Vector3d &omega, Eigen::Vector3d &alpha, float dt);
 
private:
    // 测量噪声协方差 R 和 状态误差协方差 P
    // 初始化为单位矩阵乘以一个相对较小的置信系数 0.1
    Eigen::Matrix3d R = Eigen::Matrix3d::Identity() * 0.1;
    Eigen::Matrix3d P = Eigen::Matrix3d::Identity() * 0.1;  
};
}
#endif

在这里，值得注意的是协方差矩阵 P 和 R 都是 $3 \times 3$ 的矩阵。这就是我们在上一篇中提到的：状态虽为四元数（4维），但为了满足归一化约束，我们对**误差角（3维）**进行协方差维护。

2. 状态预测函数：`predict`

预测函数的任务是通过当前的角速度 $\omega$ 和角加速度 $\alpha$ 积分，求出这 $\Delta t$ 时间内的微小旋转，然后更新四元数。

Eigen::Quaterniond ekf::predict(const Eigen::Quaterniond &q, const Eigen::Vector3d &omega, const Eigen::Vector3d &alpha, float dt)
{
    // 计算在这 dt 时间内的角度变化量 (delta_theta)
    Eigen::Vector3d delta_theta = (omega + alpha * dt) * dt;
    float theta = delta_theta.norm(); // 求出旋转角的模长
    
    Eigen::Quaterniond q_update;
    
    // 为了防止浮点数精度问题以及计算效率，当角度极小时采用一阶泰勒近似
    if(theta < 1e-6)
    {
        q_update = Eigen::Quaterniond(1, 0.5 * delta_theta.x(), 0.5 * delta_theta.y(), 0.5 * delta_theta.z());
    }
    else 
    {
        // 角度较大时，严格按照轴角转换为四元数
        q_update = Eigen::Quaterniond(Eigen::AngleAxisd(theta, delta_theta.normalized()));
    }
    
    // 四元数乘法完成姿态的预测叠加
    return q * q_update;
}

3. 雅可比矩阵：`calculate_jacobian`

这里构建了反对称矩阵（Skew-symmetric matrix），用于计算雅可比矩阵 $J$：

Eigen::Matrix3d ekf::calculate_jacobian(const Eigen::Quaterniond &q, const Eigen::Vector3d &omega, float dt)
{
    Eigen::Matrix3d j;
    Eigen::Matrix3d omega_skew;

    // 构造角速度的反对称矩阵
    omega_skew << 0,         -omega.z(),  omega.y(),
                  omega.z(),  0,         -omega.x(),
                 -omega.y(),  omega.x(),  0;

    // 根据一阶近似，计算状态转移/观测的雅可比矩阵
    j = Eigen::Matrix3d::Identity() + 0.5 * dt * omega_skew;
    return j;
}

4. EKF 核心更新逻辑：`ekf_update`

这个函数是整个滤波器的灵魂所在，它结合了前两个函数，完成“预测-计算增益-修正-更新协方差”的闭环。

void ekf::ekf_update(Eigen::Quaterniond &q, const Eigen::Vector3d &omega, Eigen::Vector3d &alpha, float dt)
{
    // 1. 预测步：得到先验状态 q_u
    Eigen::Quaterniond q_u = predict(q, omega, alpha, dt);
    
    // 2. 计算雅可比矩阵 J
    Eigen::Matrix3d J = calculate_jacobian(q, omega, dt);
    
    // 3. 计算残差：用实际测量的状态 q 乘以预测状态的逆 q_u.inverse()
    // 注意：在这里的实现中，传入的 q 被视为带有测量信息的最新状态
    Eigen::Quaterniond q_r = q * q_u.inverse();
    // 提取残差四元数的虚部（向量部分）作为测量残差向量
    Eigen::Vector3d z_r(q_r.x(), q_r.y(), q_r.z());

    // 4. 计算卡尔曼增益 K
    // 公式: K = P * H^T * (H * P * H^T + R)^-1
    // (代码将雅可比矩阵 J 作为 H 矩阵直接代入观测模型中计算)
    Eigen::Matrix3d K = P * J.transpose() * (J * P * J.transpose() + R).inverse();
    
    // 5. 计算误差修正量
    Eigen::Vector3d Kz = K * z_r;
    
    // 6. 后验状态更新：将算出的误差转换为四元数，乘上之前的预测值
    q = q_u * Eigen::Quaterniond(1, Kz[0], Kz[1], Kz[2]);
    
    // 7. 更新协方差矩阵 P
    P = (Eigen::Matrix3d::Identity() - K * J) * P;
}

总结

这段代码是一个非常轻量且实用的工程化 EKF 实现，它舍弃了标准 EKF 中过于繁琐的矩阵运算（例如舍弃了复杂的高维状态转移阵，精简了观测矩阵提取的步骤），直接针对“四元数位姿跟踪”这一特定场景进行了极致优化。通过协方差降维和一阶近似泰勒展开，使得这套算法可以在算力有限的嵌入式设备（如各类机器人的下位机/视觉板）上高速运行。

至此，我们的 EKF 算法详解系列就全部结束了！希望这三篇文章能帮你从概念到数学，再到代码落地，彻底打通 EKF 的任督二脉。

关于github的一些使用方法

Wed, 12 Nov 2025 00:00:00 GMT

GitHub 是一个面向开源及私有软件项目的托管平台，因为只支持 Git 作为唯一的版本库格式进行托管，故名 GitHub。它不仅是代码仓库，还是一个强大的协作工具。本文将介绍一些 GitHub 的基本使用方法。

准备工作：安装 Git

在开始使用 GitHub 之前，你的电脑上需要安装 Git。Git 是一个免费、开源的分布式版本控制系统，是与 GitHub 交互的基础。

你可以从 Git 官网下载适合你操作系统的安装包。安装过程通常很简单，保持默认设置即可。

安装完成后，你可以在终端（Windows 上的 PowerShell 或 CMD，macOS/Linux 上的 Terminal）中输入以下命令来验证 Git 是否安装成功：

git --version

如果能看到版本号，说明 Git 已经成功安装。

核心概念

在开始使用 GitHub 之前，了解一些核心概念非常重要：

仓库 (Repository): 你的项目存放的地方。可以想象成一个项目的文件夹，里面包含了项目的所有文件和修订历史。
克隆 (Clone): 将远程仓库复制到你的本地计算机上。
提交 (Commit): 将你的代码更改保存到本地仓库。每次提交都有一个唯一的 ID 和一条描述信息。
推送 (Push): 将本地仓库的提交上传到远程仓库（例如 GitHub）。
拉取 (Pull): 从远程仓库获取最新的更改并合并到你的本地仓库。
分支 (Branch): 为了在不影响主线（通常是 main 或 master 分支：这几年估计都改成了main，说是master有奇怪的隐喻😅）开发的情况下进行功能开发或修复 bug，你可以创建一个分支。开发完成后，再将分支合并到主线。
拉取请求 (Pull Request / PR): 当你希望将你的分支合并到另一个分支时，你可以创建一个拉取请求。这是一个请求审查和讨论你的代码更改的地方。
合并 (Merge): 将一个分支的更改合并到另一个分支。

基本工作流程

1. 创建一个新的仓库

登录你的 GitHub 账户。
点击右上角的 "+" 图标，然后选择 "New repository"。
为你的仓库命名，添加一个可选的描述。
选择 "Public"（公开）或 "Private"（私有）。
你可以选择使用 README 文件、.gitignore 文件和许可证来初始化仓库。
点击 "Create repository"。

2. 克隆仓库到本地

要对仓库进行更改，你需要先把它克隆到你的电脑上。

git clone https://github.com/your-username/your-repository.git

将 your-username 和 your-repository 替换为你的 GitHub 用户名和仓库名。

3. 添加和提交更改

在本地对项目文件进行修改后，你需要将这些更改提交到本地仓库。

# 进入仓库目录
cd your-repository

# 查看文件状态
git status

# 添加所有更改的文件到暂存区
git add .

# 提交更改，并附上描述信息
git commit -m "你的提交信息，例如：添加了新功能"

4. 推送更改到 GitHub

提交到本地仓库后，你需要将这些更改推送到 GitHub 上的远程仓库。

git push origin main

(main 可能是你的主分支名，也可能是 master)

分支与协作

分支是 GitHub 协作的核心。

1. 创建并切换到新分支

# 创建一个名为 feature-x 的新分支并切换过去
git checkout -b feature-x

2. 推送新分支到 GitHub

在你的新分支上进行提交后，将该分支推送到远程仓库。

git push origin feature-x

3. 创建拉取请求 (Pull Request)

在 GitHub 上你的仓库页面，你会看到一个提示，可以为 feature-x 分支创建一个拉取请求。
点击 "Compare & pull request"。
填写标题和描述，说明你的更改内容。
点击 "Create pull request"。

之后，项目维护者可以审查你的代码，提出修改意见，最后将其合并到主分支中。

GitHub Pages

GitHub Pages 是 GitHub 提供的一个静态网站托管服务。你可以用它来托管你的个人博客、项目文档等。

确保你的仓库中有一个 index.html 文件。
进入仓库的 "Settings" 页面。
在左侧菜单中选择 "Pages"。
在 "Source" 部分，选择你想要部署的分支（通常是 main）。
保存后，GitHub 会为你的网站生成一个 URL，格式通常是 https://your-username.github.io/your-repository/。

希望这篇指南能帮助你更好地开始使用 GitHub！

Windows与ubuntu双系统的安装

Wed, 01 Oct 2025 00:00:00 GMT

Windows下ubuntu双系统的安装

前言

我们IST实验室选择了Ubuntu作为视觉工作的系统，通常使用22.04版本。详细安装流程见下文。

如果你想生动地了解如何下载，可以去这个网址 B站教学看视频学习。

准备工作

一台已安装 Windows 的电脑
至少 100GB 的可用磁盘空间
一个 8GB 及以上的 U盘（用于制作 Ubuntu 启动盘）
Ubuntu 镜像文件（可从官网 https://ubuntu.com/download 获取）
备份重要数据，防止操作失误导致数据丢失
有问题时不用慌，先去看一下后文的常见问题有没有解决方案，也可以询问AI

Windows 分区调整

打开“磁盘管理”工具（Win+X → 磁盘管理）。
右键 C 盘或其他分区，选择“压缩卷”，为 Ubuntu 预留空间（建议 20GB 以上）。
压缩后会出现“未分配空间”，无需新建分区，安装时由 Ubuntu 自动分配。

制作 Ubuntu 启动盘

下载并安装 Rufus 工具（官网地址）。
插入 U盘，打开 Rufus，选择下载好的 Ubuntu 镜像。
保持默认设置，点击“开始”制作启动盘。

BIOS/UEFI 设置

重启电脑，进入 BIOS 设置（根据不同电脑品牌自行查询）。
将 U盘设置为第一启动项。
若为 UEFI 模式，建议关闭安全启动（Secure Boot）。

安装 Ubuntu

插入启动盘，重启电脑进入 Ubuntu 安装界面。
选择“安装 Ubuntu”。
安装类型选择“与 Windows 共存”或“其他选项”，手动选择刚才压缩出的未分配空间。（个人推荐最好选择“与 Windows 共存”，操作简单）
设置分区（推荐：/ 根分区 20GB+，swap 2GB+，/home 可选）。
按提示完成安装，期间设置用户名、密码等。

引导修复与启动选择

安装完成后，重启电脑会进入 GRUB 引导界面，可选择 Windows 或 Ubuntu。
若未出现 GRUB，可用启动盘进入 Ubuntu，安装并运行 boot-repair 工具修复引导。

常见问题与解决

分区丢失/数据丢失：安装前务必备份重要数据。
无法进入 Ubuntu/Windows：检查 BIOS 启动项及分区设置，必要时使用 boot-repair。
GRUB 未显示：尝试修复引导或检查分区格式。
英伟达显卡安装黑屏或安全模式问题：
- 如果在安装 Ubuntu 时出现黑屏或只能进入安全模式（可视范围很小），且 Windows 进入了独显模式，有两种解决方案：
  1. 进入 Windows，关闭独显模式，重新进入安装界面。安装完成后，进入 Ubuntu，打开“附加驱动”，安装英伟达驱动，优先选择带有“test”或“专用”字样的版本。
  2. 在 GRUB 引导界面时，将光标移动到 Ubuntu 安装选项，不要回车。按“E”进入编辑模式，使用方向键向下滚动，找到以 linux 开头的一行（结尾通常是 $vt_handoff 或 quiet splash），在 splash 后面加上 nomodeset，然后按 Ctrl+X 启动。进入系统后，按方案1安装驱动。

结语

通过以上步骤，你可以在一台电脑上顺利安装并使用 Windows 与 Ubuntu 双系统。遇到问题时，可以发到群里让你亲爱的学长帮助你，如果学长也无法帮助你，可以查阅官方文档或相关社区获取帮助，如果還是無法解決，去電腦店刷機。

Anaconda及pycharm的安装

Sat, 16 Aug 2025 00:00:00 GMT

Python开发环境搭建指南：Anaconda与PyCharm安装教程

前言

本文是为Python新手准备的开发环境配置指南。对于初学者，我们强烈推荐使用Anaconda和PyCharm的组合——Anaconda提供了完整的Python环境和科学计算库，而PyCharm则是专业的Python开发工具，二者搭配能显著降低学习门槛。

一、Anaconda安装指南

1. Anaconda是什么？

Anaconda是Python的一个发行版，它包含：

Python解释器
Conda包管理器（比pip更强大的依赖管理）
180+预装科学计算库（如NumPy, Pandas, Matplotlib等）
Jupyter Notebook等实用工具

安装Anaconda后就无需单独安装Python和其他基础库了。

2. 下载安装包

2.1 官方渠道（不推荐新手使用）

官网地址：https://www.anaconda.com

2.2 国内镜像（推荐）

清华大学开源镜像站： https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/

选择对应操作系统（由于清华源内容很多，找的时候一定要看清）：

3. 详细安装步骤（Windows示例）

运行安装程序：双击下载的.exe文件
用户选择：建议选择"Just Me"（仅当前用户）
安装路径：建议修改为D:\Anaconda3等非系统盘路径，别安装到C盘就行
高级选项（关键步骤）：
- ✅ Add Anaconda to my PATH environment variable(如果你想要自己手动添加到环境变量也可以不勾选)
- ✅ Register Anaconda as my default Python 3.x
等待安装完成（约10-20分钟）

4. 验证安装

打开命令提示符（Win+R → 输入cmd），执行：

conda --version
# 应显示类似：conda 23.7.4

二、pycharm安装指南

1. PyCharm 是什么？

PyCharm 是 JetBrains 开发的一款专业 Python IDE，具备：

智能代码补全与语法高亮
图形化调试器 & 测试运行器
Git / SVN / Docker 等一键集成
内置终端、虚拟环境管理与 Conda 支持
科学模式（Scientific Mode），可无缝调用 Anaconda 中的 NumPy、Matplotlib 等库

2. 下载安装包

1 官方渠道（推荐）

官网地址：https://www.jetbrains.com/pycharm/download
之前本来还分社区版（白嫖）和专业版（氪佬），但是好像这段时间统一成一个程序里了，可选择pro用户。

3. 详细安装步骤（Windows 示例）

运行安装程序
双击下载的 pycharm-2024.x.x.exe → 点击 “Next”。
安装路径
建议改为 D:\JetBrains\PyCharm 2024.x，避免 C 盘空间不足。
安装选项（建议全部勾选）
- ✅ Create Desktop Shortcut（64-bit launcher）
- ✅ Add "Open Folder as Project"
- ✅ .py 关联
- ✅ Add launchers dir to the PATH（后续命令行可直接 pycharm 打开，没错，这也是为什么anaconda也让你放环境中的理由）

4. 配置conda环境

1.在你的任务栏中搜索anaconda prompt，打开之后输入

conda create -n myenv python=3.11

在这里myenv是你创建的虚拟环境的名字，3.11是这个环境中python的版本号 2.稍等片刻后输入

conda activate myenv

3.像这样你就创建成功了

5. 配置 Anaconda 解释器（关键步骤）

可以先去网上搜索中文插件

新建项目
打开 PyCharm → New Project → Location 填写 D:\Code\PyDemo。
选择 Conda 环境
- 直接打开右下角的地方，如图，选择添加新的解释器
- 选择现有，类型选择conda类型，conda路径在anaconda的下载地址中找类似于我这个 E:\anaconda\Scripts\conda.exe（我安装到了E盘）
- 环境选择我们刚才创建好的myenv，点击确认
验证
新建 hello.py 输入以下代码并运行 Shift+F10：
```
print("hello world")
```
如果可以正常输出hello world那么就成功安装好了。

Galileo

C++ 指针入门：地址、解引用与内存访问

1. 变量、对象和地址

2. 指针是保存地址的变量

3. 解引用：通过地址访问对象

4. 指针自己也有地址

5. 指针类型为什么重要

6. nullptr：明确表示“不指向对象”

7. 指针作为函数参数

8. 常见错误

8.1 未初始化指针

8.2 空指针解引用

8.3 悬空指针

8.4 越界指针访问

9. 小结

C++ 系列前言：从语法到工程能力

C++ 系列前言：从语法到工程能力

1. 为什么重新整理 C++

2. 这个系列想解决什么问题

3. 写作方式

4. 暂定目录

第一部分：C++ 基础概念

第二部分：对象与内存管理

第三部分：STL 与常用容器

第四部分：编译、调试与工程工具

第五部分：小项目实践

5. 需要先建立的几个判断

6. 从哪里开始

C++ 系列

系列目录

Linux系统

系列目录

Linux常用指令入门

1. 查看当前所在位置

2. 查看目录内容

3. 切换目录

4. 创建文件和目录

5. 复制、移动和重命名

6. 删除文件和目录

7. 查看文件内容

8. 搜索文件内容

9. 查找文件

10. 查看磁盘和文件大小

11. 查看和结束进程

12. 权限相关命令

13. 压缩和解压

14. 网络相关命令

15. 常用组合

总结

EKF 算法详解：(一) 简介与基础

1. 什么是卡尔曼滤波 (Kalman Filter)?

标准 KF 的局限性

2. 为什么需要扩展卡尔曼滤波 (EKF)?

EKF 的优势：

3. EKF 算法的通用五步公式

预测阶段 (Predict)

更新阶段 (Update)

4. 结语与预告

EKF 算法详解：(二) 姿态解算与数学推导

1. 为什么使用四元数与误差状态？

2. 状态预测方程 (Prediction)

3. 雅可比矩阵的计算 (Jacobian)

4. 状态更新方程 (Update)

EKF算法概述

系列目录

EKF 算法详解：(三) 源码解析实现

1. 类的定义与初始化 (ekf.hpp)

2. 状态预测函数：predict

3. 雅可比矩阵：calculate_jacobian

4. EKF 核心更新逻辑：ekf_update

总结

关于github的一些使用方法

准备工作：安装 Git

核心概念

基本工作流程

1. 创建一个新的仓库

2. 克隆仓库到本地

3. 添加和提交更改

4. 推送更改到 GitHub

分支与协作

6. `nullptr`：明确表示“不指向对象”

1. 类的定义与初始化 (`ekf.hpp`)

2. 状态预测函数：`predict`

3. 雅可比矩阵：`calculate_jacobian`

4. EKF 核心更新逻辑：`ekf_update`