C++ on Galileo Y

女神拒绝我后，C++ 成了我的命中劫

Fri, 15 May 2026 00:00:00 +0800

女神拒绝我后，C++ 成了我的命中劫

1. 故事开始之前

遥想当年，高考结束以后，很多人都在忙着和自己的女神或者男神表白，试图给青春画上一个浪漫的句号。

而我，在那个本该热血、暧昧、充满青春滤镜的夏天，也展示出了自己非常独特的一面——

我压根没去理那个陪伴了我整个青春时期的女神。

当然，听起来好像挺潇洒。

实际情况是：我在高考前就已经表白过了，人家压根没搭理我。

所以严格来说，并不是我没有选择爱情，而是爱情没有选择我。

于是，高考结束后的我，带着一种“反正也没人理我”的洒脱，开始疯狂游玩。那段时间没有作业，没有考试，也没有早八，人生看起来突然自由得有些不真实。

但这种自由没有持续太久。

疯玩了一阵之后，我慢慢感受到了一种很奇怪的空虚。每天好像都很轻松，但又总觉得少了点什么。以前被考试推着走，至少知道自己每天为什么起床；可当那个目标突然消失以后，我反而不知道自己该往哪里走了。

就在这个时候，我看到了大学实验室开始招新。

那一刻，我和 C++ 的缘分，算是正式开始了。

2. 为什么偏偏是 C++

说实话，我一开始并没有什么特别宏大的目标。

不是因为我突然立志要成为系统架构师，也不是因为我那时候已经理解了什么叫高性能计算、底层开发、内存模型、工程能力。

更真实的情况是：我只是觉得，实验室里的东西看起来很酷。

写代码、跑程序、做项目、调设备，这些事情听起来比单纯上课更接近我想象中的“真正的技术”。而 C++，正好就是那个我绕不开的入口。

后来接触得多了，我慢慢意识到，C++ 这门语言很特别。

它不像 Python 那样一上来就很舒服，也不像很多脚本语言那样可以快速看到结果。C++ 经常让人痛苦：指针、引用、内存、对象生命周期、编译链接、模板、构造析构……每一个概念都像是在提醒你：

你以为你懂了？其实你还差得远。

但也正是因为这样，C++ 很适合用来训练一个人的工程基本功。

它会逼着你去理解程序到底是怎么运行的，变量到底放在哪里，内存为什么会泄漏，对象什么时候创建、什么时候销毁，为什么有些代码看起来没问题但运行起来就是崩。

这种感觉一开始很折磨，但后来我发现，这可能正是我需要补上的东西。

3. 我现在并不熟练

必须承认，我现在并不是一个很熟练的 C++ 使用者。

很多东西我还在补。

比如指针和引用，我以前知道怎么写，但不一定真的知道它们在内存里意味着什么。

比如 const，我知道它表示“常量”，但遇到 const int*、int* const、const int& 的时候，还是会忍不住停下来想一想。

比如构造函数、析构函数、拷贝构造、移动语义，这些词看起来都认识，但真要在工程里写对，其实没那么简单。

再比如 CMake、gdb、Linux 编译链接这些东西，以前总觉得它们只是工具，后来才发现，工程开发里很多问题根本不是算法问题，而是你连程序怎么编译、怎么链接、怎么调试都没搞明白。

所以这个系列不是“C++ 高手教程”。

更准确地说，它是一个学习记录。

我想把自己从“会写一点 C++ 语法”，慢慢推进到“能写比较可靠的 C++ 工程代码”的过程记录下来。

4. 目录

这个系列会从 C++ 最基础、最容易混乱的概念开始，一步一步往工程化方向推进。

目前暂定目录如下，后面会根据学习进度不断补充和调整。

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

变量、地址和指针：我终于理解了指针是什么
引用和指针到底有什么区别
const 到底修饰的是谁
栈和堆到底有什么区别
new/delete 和 malloc/free 有什么区别

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

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

第三部分：STL 与常用容器

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

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

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

第五部分：小项目实践

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

这些标题不一定一次性全部写完。

它们更像是一张路线图：我会先从最基础的问题开始，慢慢把 C++ 这条路走清楚。

5. 我想用什么方式学 C++

我以前也看过不少教程，但看教程有一个问题：当时好像懂了，过几天又忘了。

后来我发现，真正能留下来的东西，往往不是“我看懂了什么”，而是“我亲手验证过什么”。

所以这个系列里，我会尽量按照这样的方式写：

我为什么学这个问题
我一开始哪里不理解
用一段最小代码复现现象
观察运行结果
解释背后的原因
最后写下我目前的理解

如果还有没搞懂的地方，我也会直接写出来。

因为学习本来就不是一次性完成的。

有些概念第一次只能理解 50%，过一段时间写项目遇到了，再回头看，可能才能理解到 80%。再等真正踩坑了，才会突然意识到：原来书上那句话是这个意思。

6. 为什么要把这些写在 blog 上

一方面，是为了逼自己输出。

如果只是看视频、看书、写一点零散代码，很容易产生一种“我学过了”的错觉。但真正写成文章时，你会发现很多东西其实没有想清楚。

你能不能把一个概念讲明白，往往能暴露你到底懂没懂。

另一方面，我也希望这个 blog 不是一个空荡荡的简历页面，而是一个能看见成长轨迹的地方。

我不想把自己包装成一个已经很厉害的人。

我更希望别人在阅读我博客的时候感受到的是：

这个人选择的方向很有趣诶，看看他都踩过哪些坑，他在前面都有什么经验总结吧

这对我来说就够了。

7. 从这里开始

所以，这个 C++ 系列就从这里开始。

它的起点不是某个宏大的项目，也不是某个听起来很厉害的技术名词。

它的起点只是一个很普通的问题：

我想真正把 C++ 学明白。

从指针、引用、const、栈和堆这些基础概念开始，一点点往前走。

也许这个过程会很慢，也许中间会反复踩坑，也许有些文章以后回头看会觉得幼稚。

但没关系。

至少从这里开始，我不是只是在“学过 C++”。

而是在认真尝试理解它。

她没给我联系方式，但变量给了我地址：C++ 指针入门

Sun, 17 May 2026 00:00:00 +0800

本文是 C++ 学习记录系列的第二篇。

上一篇：女神拒绝我后，C++ 成了我的命中劫

这个事情还得从疫情期间说起，当时我正上高二，因为在学校旁边租了房子所以不怎么去上晚自习。母上大人作为家委会成员和班主任的关系还很不错（这个家委会的职位纯粹是想和老师打好关系在学校监视我才做的）。有一天晚上班主任给我妈打电话了说我们班有一个密切和患者接触过的人，于是我妈让我从家出发去班里通知————开（放）始（假）网（回）课（家）。正如我所说的，租的房子距离学校很近，所以我五分钟就到了给他们宣布了这好消息。但是我依旧等了很长时间————当时不只我一个人走读，还有同学正在回来取书的路上。

我当时就在教室里等待着我的同桌————看过前言的朋友应该都知道这是我对我同桌是什么意思了————总而言之，等到她来了以后，我就做了青春期小男生都会做的事情，我开始尽可能找话题聊天。

走运的是我确实要到了她的联系方式，但是我真不知道人家的地址————友情提醒，在任何情况下贸然了解非熟人的地址都是一件涉及隐私的行为，慎行。但是请不要看到这就说我 Galileo 标题党，恰恰相反，虽然有了联系方式，但是我在最后还不如没有呢！想知道后面发生了什么，请你耐心地读到到后面的 C++ 系列吧。:）

不过回到 C++，情况就简单多了。

现实里不能随便问人家的地址，但程序里的变量很大方：只要你写一个 &，它就会把自己的内存地址交出来。

这篇文章要讲的指针，本质上就是在回答一个问题：如果我知道了一个变量的地址，我到底能做什么？

1. 先从变量开始

在理解指针之前，先要理解一个普通变量在程序里至少包含几层信息：

变量名：代码里用来访问它的名字
变量类型：决定这块数据应该如何解释
变量值：变量当前保存的数据
变量地址：变量在内存中的位置

比如下面这段代码：

#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 的地址，也就是它在内存中的位置。

需要注意的是，地址每次运行都可能不一样。我们不需要记住某个具体地址，只需要理解：变量除了有值之外，也有自己的内存地址。

如果继续用前面的故事类比，变量名有点像“我在代码里怎么称呼它”，变量值是它当前保存的内容，而变量地址才是它在内存里的具体位置。

联系方式和地址不是一回事，变量名和变量地址也不是一回事。

2. 指针到底是什么

指针本质上也是一个变量。

只不过普通变量保存的是普通数据，而指针变量保存的是地址。

也就是说，指针不是变量本身，而是一个“记着变量地址的小纸条”。

（啊这让我想到了我的好homie，当时他也在追一个姑娘，可以说死缠烂打，终于又一次在晚自习时写在纸条上的表白被答应了，但是刚答应，纸条就被班主任收走看见了，从严格意义上来讲，班主任是第一个知道女生小心思的人，纸条返回的地址输出给班主任了，他没看到）

纸条上写着地址，你顺着地址才能找到真正的数据。

#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

这段代码里有三个符号特别关键：

&a：取出变量 a 的地址
p：保存变量 a 的地址
*p：根据 p 里保存的地址，找到对应变量并访问它的值

所以这行代码：

int* p = &a;

可以理解为：

创建一个 int* 类型的指针变量 p，让它保存 a 的地址。

这里的 int* 表示：p 是一个指针，它指向的对象类型是 int。

所以标题里说“变量给了我地址”，放到代码里就是这句：

int* p = &a;

a 把地址交出来，p 负责把这个地址保存好。

3. 通过指针修改变量

因为指针保存的是变量地址，所以我们可以通过指针找到原来的变量，并修改它。

#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 保存 a 的地址。

而：

*p = 20;

表示通过 p 找到 a，然后把 a 改成 20。

这里最容易误会的是：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 这个变量自己住在一个地址里，而它里面保存的值又是另一个变量的地址。

换成刚才的小纸条类比就是：纸条上写着 a 的地址，但纸条本身也得放在某个地方。

p 是纸条上写的内容，&p 是这张纸条自己的位置。

这可不要弄混，不然就会像我的学长一样，本来是想加p学姐和人家认识认识聊聊人生，但是加成了&p学姐，这下好了，他用了一个月发现了error，但是你的报错可是会瞬间给你一巴掌。

5. 指针类型为什么重要

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

它还带着类型信息。

比如 int* 表示这个指针指向的是 int，double* 表示这个指针指向的是 double。

类型至少影响两件事：

解引用时，编译器应该按什么类型读取数据
指针做加法时，地址应该移动多少字节

看下面这个例子：

#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，而是让地址向后移动 1 个 int 的大小，也就是 4 个字节。

所以指针加法不是简单的数字加法，而是和指针指向的类型有关。

这就像只知道“地址”还不够，你还得知道那里住的到底是什么类型的对象。

如果 p 指向的是 int，那往后走一步就是下一个 int；如果指向的是 double，往后走一步就要按 double 的大小来走。

C++ 不会只问“你要去哪”，它还会问“你要按什么规格走”。

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';

对空指针解引用会导致未定义行为，程序可能直接崩溃。

这件事也很好理解：你手里没有地址，却非要按地址去找东西，那程序只能当场迷路。

nullptr 的意义不是让你去访问它，而是提醒你：这个指针现在还没有目标。

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

这里 changeByValue 拿到的是 a 的一份拷贝，函数内部修改的是拷贝，不会影响外面的 a。

再看传指针：

#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，并修改它。

这也是很多 C 风格接口喜欢传指针的原因：函数可以通过地址访问调用者传进来的对象。

所以传指针的威力更大，责任也更大。

你把地址交出去了，函数就不只是看看，它是真的可能改到原来的对象。

8. 几个我踩过的坑

8.1 未初始化指针

int* p;

// 错误示范：p 没有被初始化，不知道指向哪里
*p = 10;

未初始化的指针里可能是任意地址。

直接解引用它非常危险。

这就像手里拿了一张没写清楚的纸条，却硬说它是情书，上面记了人家要和你表白的地址。

你顺着它走，走到哪里完全看运气，而写程序最不应该靠运气，感情也是，万一那是年级主任钓鱼用的呢。

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

int* p = nullptr;

你要是写情书的话另说，这东西不兴有模版或者定义之类的。

8.2 空指针解引用

int* p = nullptr;

// 错误示范
std::cout << *p << '\n';

nullptr 不指向任何有效对象，不能通过 *p 访问。

它至少比未初始化指针诚实：未初始化指针是不知道自己去哪还乱跑，nullptr 是明确告诉你“我现在哪也不去”。

8.3 悬空指针

int* p = nullptr;

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

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

a 是代码块里的局部变量。

当代码块结束后，a 的生命周期结束，p 还保存着原来的地址，但那个地址对应的对象已经不存在了。

这种指针叫悬空指针。

这个坑很像你保存了一个旧地址，但那个人早就搬走了。

地址看起来还像个地址，但你再按它去找，找到的已经不是原来的对象。

9. 总结

这一篇先抓住几句话就够了：

变量有值，也有地址
&a 表示取出变量 a 的地址
指针变量保存的是地址
*p 表示根据指针保存的地址访问对象
指针类型会影响解引用和指针运算
不确定指向谁的指针，先初始化为 nullptr

类比一下就是：

变量名像称呼，变量值像当前内容，变量地址像它在内存里的位置，指针像一张专门保存地址的纸条。

但 C++ 比现实世界更严格：你可以拿地址，也可以顺着地址改东西，可一旦地址是假的、空的、过期的，程序就会用崩溃或者未定义行为提醒你，这事不能乱来。尤其是当女生给你了假的联系方式的时候（当然人家肯定没给我假的，不然也没后面的事了）

如果把这几个点想清楚，后面再看引用、数组、动态内存、对象生命周期，都会顺很多。

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

Thu, 12 Mar 2026 00:00:00 +0800

本文是 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 的任督二脉。

C++ on Galileo Y

女神拒绝我后，C++ 成了我的命中劫

女神拒绝我后，C++ 成了我的命中劫

1. 故事开始之前

2. 为什么偏偏是 C++

3. 我现在并不熟练

4. 目录

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

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

第三部分：STL 与常用容器

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

第五部分：小项目实践

5. 我想用什么方式学 C++

6. 为什么要把这些写在 blog 上

7. 从这里开始

她没给我联系方式，但变量给了我地址：C++ 指针入门

1. 先从变量开始

2. 指针到底是什么

3. 通过指针修改变量

4. 指针自己也有地址

5. 指针类型为什么重要

6. 空指针 nullptr

7. 指针作为函数参数

8. 几个我踩过的坑

8.1 未初始化指针

8.2 空指针解引用

8.3 悬空指针

9. 总结

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

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

2. 状态预测函数：predict

3. 雅可比矩阵：calculate_jacobian

4. EKF 核心更新逻辑：ekf_update

总结

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

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

3. 雅可比矩阵：`calculate_jacobian`

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