第 34 章 · 性能优化与别名陷阱

这一章能帮你少踩 Eigen 最经典的坑：别名问题、auto 陷阱，以及一系列性能优化技巧。

34.1 别名问题：左右两边共用内存

别名（aliasing）：赋值语句左右两边引用同一块内存时，可能"边读边写"导致错误。

Eigen 只在一部分场景自动帮你兜底，剩下的要你自己判断。下面三档都是本书的实测结论（Eigen 5.0 + MinGW GCC 16.1，-O0与-O2结果一致），别背成"口诀"要理解为什么。

第一档：Eigen 自动处理，随便写

a=a*a;// 矩阵乘法：自动用临时变量，安全a=2*a;// 标量乘法：安全a=a*a.transpose();// 矩阵乘法里带转置：同样安全（实测 5 11 / 11 25）a=a.array().square();// 只有一个操作数的逐元素自运算：实测安全a=a.array().exp();// abs / sqrt / min(标量) 等单目运算同上v=v.array().square();// 向量版也安全

纠正一个流传很广的说法：很多资料写"逐元素自运算不安全，必须加.eval()"。实测并非如此——单操作数的square()、exp()、abs()无论Matrix还是Array、无论哪个优化级别，结果都和加.eval()的版本逐元素相同（如a为 1 2 / 3 4 时平方得 1 4 / 9 16）。加.eval()不会出错，只是多一次拷贝；但别把"不加就错"当规则背，那会让你把注意力放错地方。

真正危险的是第二个操作数带转置的情形，见下面两档。

第二档：Debug 会断言，Release 静默算错

t=t.transpose();// Debug：断言中止m=m+m.transpose();// Debug：断言中止m.block<2,2>(0,0)=m.block<2,2>(0,0).transpose();// Debug：断言中止

断言原文（Eigen 自己的文件，别去改它）：

Assertion failed: (...) "aliasing detected during transposition, use transposeInPlace() or evaluate the rhs into a temporary using .eval()", file Eigen/src/Core/Transpose.h, line 402

换编译器再验一遍：同一份代码用 MSVC 的cl /std:c++17 /EHsc /utf-8（Visual Studio 2022）编译，断言原文一模一样，只有行号是Transpose.h, line 406（不同编译器展开模板的行数略有差别）。两个独立编译器给出同一个结论，这条规则不是 MinGW 的个例。

关键坑：这个检查靠assert实现，而 Release 构建定义了NDEBUG，断言会被整个编译掉，程序继续跑并给出错误结果。实测t = t.transpose()（初始t为 1 2 / 3 4）：

构建方式	实际输出	正确结果
Debug（保留断言）	断言中止，告诉你怎么办	—
Release（-O2 -DNDEBUG）	1 2 / 2 4❌	1 3 / 2 4
MSVC Release（/O2 /DNDEBUG）	1 2 / 2 4❌（与 g++ 一致）	1 3 / 2 4
Debug +-DEIGEN_NO_DEBUG	断言消失，1 2 / 2 4❌	1 3 / 2 4

也就是说：只在 Release 里试过、没报错，不等于安全。

关于EIGEN_NO_DEBUG：Eigen 的这批检查全靠assert，所以只要 assert 被关掉，保护就一起没了——不管是-DNDEBUG（Release）还是显式定义EIGEN_NO_DEBUG。实测在-O0、没加-DNDEBUG的 Debug 构建上定义EIGEN_NO_DEBUG，转置自赋值不再中止，直接给你错的1 2 / 2 4；第 26 章 26.3 讲的"动态矩阵尺寸不匹配"也一样（断言消失、静默返回错误结果）。除非你在排查 Eigen 内部行为，不要定义这个宏。

两种正确写法：

t.transposeInPlace();// ✅ 原地转置，就是为这种自赋值设计的t2=t2.transpose().eval();// ✅ 先把右边结算成一个独立结果

第三档：连 Debug 都不报，一直静默算错

Eigen::Matrix2d a;a<<1,2,3,4;a=a.array()*a.transpose().array();// 无警告、无断言

实测-O0和-O2都打印：

1 12 6 16

而正确答案是1 6 / 6 16：元素 (0,1) 乘的是已经被改写过的a(1,0)。更值得注意的是，同一句话把Matrix2d换成ArrayXXd就会触发第二档的断言——Eigen 的别名检查不覆盖所有写法，"没报错"不能作为安全证明。

修法与第二档相同，整块包住更保险（实测两种写法在 Debug/Release 下都能得到正确的1 6 / 6 16）：

a=(a.array()*a.transpose().array()).eval();// ✅ 整个右先算成临时结果Eigen::Matrix2d tmp=a.array()*a.transpose().array();// ✅ 或借助临时变量a=tmp;

保命规则

1. 右边出现transpose()/adjoint()/block且和左边共用内存 → 一律.eval()，或改用xxxInPlace()（如transposeInPlace()）。
2. 拿不准就先赋给一个临时变量，再写回。
3. 一定要用 Debug 构建跑一遍——断言只在 Debug 生效，Release 只会静默给你错数。

记忆：矩阵乘法自动安全；单操作数的逐元素自运算实测安全；只要右边带转置就要.eval()或用InPlace，因为 Release 下没有任何人会提醒你。

34.2 noalias()：跳过临时变量

确定左右无重叠时，用.noalias()告诉 Eigen “没有别名”，省掉临时变量，更快：

C.noalias()=A*B;// 已知 C 与 A、B 无重叠，直接写入

默认C = A * B会用临时变量保证安全（多一次拷贝）；确定安全后加.noalias()提速。

34.3 auto 陷阱

不要把矩阵表达式直接赋给auto：

Eigen::Matrix2d m;m<<1,2,3,4;// ❌ auto 捕获的是"表达式模板"，不是计算结果autoexpr=m.transpose();m<<5,6,7,8;// 改 m 后，expr 的结果会跟着变！// ✅ 用明确类型Eigen::Matrix2d good=m.transpose();// ✅ 或加 .eval() 强制求值autosafe=m.transpose().eval();

auto捕获的是"惰性表达式"（记录了"m 的转置"这个动作），m 一变，结果就变。用明确类型或.eval()就安全了。

34.4 编译优化（最重要！）

Eigen 是模板库，不开优化会慢几十倍。这是最关键的设置：

g++-std=c++17-O2-I"你的Eigen目录"main.cpp-omain# g++ 开启优化cl /std:c++17 /O2 /EHsc /utf-8 /I"你的Eigen目录"main.cpp# MSVC

CMake 则用 Release 配置（附录 C.6 的CMakeLists.txt已在单配置生成器下默认 Release）：

cmake-S.-Bbuild-DCMAKE_BUILD_TYPE=Release cmake--buildbuild--configRelease# Visual Studio 这类多配置生成器必须加 --config

实测提醒（Eigen 5.0 + MinGW g++ 16.1，程序是 500×500 双精度随机矩阵连乘 5 次）：

编译选项	实测耗时	相对-O0
-O0（CMake 的 Debug 就是这档）	约 2400 ms	1×
-O1	约 66 ms	快约 36 倍
-O2	约 65 ms	快约 37 倍
-O3	约 65 ms	快约 37 倍（与-O2无差别）

两个结论：一是"不开优化慢几十倍"不是夸张，实测就是37 倍；二是-O1已经把 Eigen 需要的优化拿满了，-O3相对-O2没有任何额外收益，所以本书统一用-O2（MSVC 用/O2），不必去追-O3。换一台机器绝对数字会变，但量级不会变。做性能对比前务必确认自己是 Release/带优化——否则你测的是编译器的优化能力，不是 Eigen 的性能。

34.5 性能要点清单

要点	说明
开编译优化	-O2/ Release，最重要
按引用传递	函数参数用const MatrixXd&，避免复制大矩阵
固定大小类型	小矩阵用Matrix3d而非MatrixXd
复用分解	solver.compute(A)放循环外，循环内只solve()
noalias	确定无别名时用，省临时变量
表达式合并	尽量写成一个表达式，减少中间临时变量

34.6 按引用传递函数参数

// ❌ 按值传递：每次调用都要复制整个矩阵，慢doublesumCopy(Eigen::MatrixXd m){returnm.sum();}// ✅ 按常量引用传递：零拷贝，快且安全doublesumRef(constEigen::MatrixXd&m){returnm.sum();}

两个函数故意起了不同的名字。如果你把它们都写成sum（一个参数是MatrixXd、另一个是const MatrixXd&），那么调用sum(A)时两个版本都算"匹配"，编译器直接报错：call of overloaded 'sum(Eigen::MatrixXd&)' is ambiguous。想对比性能就写两个名字，或者分两次编译。

34.7 常见编译错误速查

报错	原因	解决
No such file: Eigen/Dense	头文件路径没设对	加-I指向 Eigen 目录
尺寸不匹配（固定矩阵）	Matrix2d * Matrix3d这类写法本身就不成立	编译期报static assertion failed: INVALID_MATRIX_PRODUCT，改行列数
尺寸不匹配（动态矩阵）	MatrixXd的行列数要到运行期才知道	Debug 运行期断言、Release静默给你错数，见第 26 章 26.3
中文乱码	编码问题	g++ UTF-8；MSVC/utf-8
no match for operator*	Matrix/Array 混用	用.array()/.matrix()统一
固定矩阵 resize 报错	用了Matrix3d却 resize	换MatrixXd
三角视图不能 cout	分解返回视图	加.toDenseMatrix()

34.8 调试技巧

下面每一小段都是独立的检查手段，抄用时请确保上文已经把对应的m、llt、A、x、b定义好（llt见第 30 章，A、b见第 29 章）：

// 打印中间结果std::cout<<"debug: m =\n"<<m<<std::endl;// 检查分解是否成功if(llt.info()!=Eigen::Success){std::cout<<"分解失败"<<std::endl;}// 检查求解残差doubleerr=(A*x-b).norm();std::cout<<"残差 = "<<err<<std::endl;// 应接近 0// 检查有没有 NaN / Inf：数值算崩了第一时间看这个std::cout<<"含 NaN? "<<m.hasNaN()<<std::endl;// 一个 boolstd::cout<<"全都有限? "<<(m.array().isFinite()).all()<<std::endl;// 逐元素后再 .all()

hasNaN()和isFinite()的分工（实测）——m取1 2 / NaN 4，h取1 2 / 3 Inf：

写法	返回什么	m（含 NaN）	h（含 Inf）
m.hasNaN()	一个bool	true	false
m.array().isFinite()	每个元素一个bool（打印出来是一整块）	true true / false true	true true / true false
(m.array().isFinite()).all()	一个bool	false	false

两个要点：①isFinite()是逐元素的，想要"整体是否有限"必须再.all()（第 28 章的归约）；②hasNaN()认不出Inf——矩阵里出现inf时它照样返回false，所以查数值异常要认准isFinite()。实测用一个奇异矩阵A = 1 2 / 2 4解A*x = b，得到x = -inf inf，hasNaN()说"没问题"，而(x.array().isFinite()).all()正确地返回false。

34.9 本章完整示例

一个程序把本章的每个坑都走一遍正确写法（存成ch34.cpp，按附录 C.3 编译）：

#include<Eigen/Dense>#include<iostream>// ✅ 函数参数用常量引用：不复制整个矩阵（34.6）doublesumOf(constEigen::MatrixXd&m){returnm.sum();}intmain(){// 1) 矩阵乘法：Eigen 自动用临时变量，左右同源也安全Eigen::Matrix2d a;a<<1,2,3,4;a=a*a;std::cout<<"a = a * a 之后:\n"<<a<<"\n";// 2) 转置自赋值：必须 transposeInPlace() 或 .eval()（34.1 第二档）Eigen::MatrixXdt(2,3);t<<1,2,3,4,5,6;t.transposeInPlace();std::cout<<"t 原地转置后（3x2）:\n"<<t<<"\n";// 3) 单操作数的逐元素自运算：实测安全，不需要 .eval()Eigen::ArrayXdv(3);v<<1,2,3;v=v.square();std::cout<<"v 逐元素平方后 = "<<v.transpose()<<"\n";// 4) 右边带 transpose 且与左边同源：整块 .eval() 才是对的（34.1 第三档）Eigen::Matrix2d w;w<<1,2,3,4;w=(w.array()*w.transpose().array()).eval();std::cout<<"w = (w.array() * w.transpose().array()).eval():\n"<<w<<"\n";// 5) 已知不重叠时用 noalias()，省掉临时矩阵Eigen::MatrixXd A=Eigen::MatrixXd::Ones(2,2);Eigen::MatrixXd B=Eigen::MatrixXd::Constant(2,2,3.0);Eigen::MatrixXdC(2,2);C.noalias()=A*B;std::cout<<"C = A * B（noalias）:\n"<<C<<"\n";// 6) auto 捕获的是"表达式"，不是结果Eigen::Matrix2d m;m<<1,2,3,4;autolazy=m.transpose();m<<5,6,7,8;// 改了 mstd::cout<<"改 m 之后再打印 lazy，它跟着变了:\n"<<lazy<<"\n";// 7) 想要"当下这份数"，用 .eval() 固化autosnapshot=m.transpose().eval();m.setZero();std::cout<<"snapshot 不受 m 影响:\n"<<snapshot<<"\n";std::cout<<"按引用求和 sumOf(m) = "<<sumOf(Eigen::MatrixXd(m))<<"\n";return0;}

运行结果：

a = a * a 之后: 7 10 15 22 t 原地转置后（3x2）: 1 4 2 5 3 6 v 逐元素平方后 = 1 4 9 w = (w.array() * w.transpose().array()).eval(): 1 6 6 16 C = A * B（noalias）: 6 6 6 6 改 m 之后再打印 lazy，它跟着变了: 5 7 6 8 snapshot 不受 m 影响: 5 7 6 8 按引用求和 sumOf(m) = 0

最能说明auto陷阱的是第 6、7 两段：lazy打印出来是改动之后的m的转置（5 7 / 6 8），而snapshot是当时算好的实体，之后m.setZero()也动不了它。最后一行sumOf(m) = 0也顺带说明：m被清零了，按引用传进去读到的就是最新状态。

动手做两个对照实验（这比读十遍规则有用）：

1. 把第 4 段的.eval()删掉，写成w = w.array() * w.transpose().array();再跑。实测它连 Debug 都不报错，直接给你1 12 / 6 16——正确值是1 6 / 6 16。这就是第三档"静默算错"的样子。
2. 把第 3 段改成v = v.square().eval();再跑，输出完全不变（还是1 4 9）。单操作数的逐元素自运算本来就安全，.eval()在这里只是多余的拷贝。

顺带把第 2 段改成t = t.transpose();：Debug 构建会当场断言中止（第二档），而 Release 构建不吭声地把t算成错的值。同一个错误写法，Debug 和 Release 表现不同——这正是"只在 Release 测过一遍"不可靠的原因。

34.10 小结

• 别名分三档：矩阵乘法自动安全；单操作数的逐元素自运算实测安全；右边带transpose()的自赋值最危险——Debug 断言、Release 静默算错，必须.eval()或用InPlace。
• 断言只在 Debug 生效，别只在 Release 里验证正确性。
• noalias()跳过临时变量。
• 别用auto捕获矩阵表达式。
• 开-O2优化是性能第一要务（实测-O0慢约 37 倍；-O1就已够，-O3相对-O2无额外收益）。
• 传参用const MatrixXd&。

下一章，学习Eigen 进阶技巧——与 STL 结合、常用模式、更多坑。

---

练习题

1. 写出安全的原地转置写法。
2. 写出w = w.array() * w.transpose().array();的安全版本，并说明原写法在 Debug 和 Release 下分别是什么表现。
3. 用.noalias()优化一个矩阵乘法赋值。
4. 演示 auto 陷阱：auto 捕获表达式后改原矩阵，观察结果变化。
5. 说说为什么开编译优化对 Eigen 这么重要。