MatrixBase<Derived>转换原理及传参sizeof差异疑问解析

Great question—this gets right to the core of how Eigen balances flexibility and performance! Let's break down exactly what's happening here, step by step.

Why the Size Difference: 1 vs. 16? #

First, let's demystify the sizeof output:

• sizeof(m) is 16 because Matrix<float, 2, 2> is a concrete type that stores its data directly. A 2x2 float matrix has 4 elements, each taking 4 bytes (standard for float on most systems), so 4×4=16 bytes total. That's straightforward.
• sizeof(b) is 1 because MatrixBase<Derived> is an empty base class. In C++, even empty classes have a minimum size of 1 byte—this ensures every object has a unique memory address. Eigen designs MatrixBase as an interface-only class: it holds no data members of its own. All the actual matrix data lives in the derived class (your Matrix<float,2,2> instance m).

What's Under the Hood When Passing to MatrixBase&? #

When you call print_size(m):

1. Template Argument Deduction: The compiler automatically deduces Derived to be Matrix<float, 2, 2>, so the function resolves to print_size(const MatrixBase<Matrix<float,2,2>>& b).
2. Base Class Reference Binding: Since Matrix<float,2,2> inherits from MatrixBase<Matrix<float,2,2>>, you're binding a base class reference to a derived class object. Eigen uses the Curiously Recurring Template Pattern (CRTP) here to make this efficient.
3. No Data Copy: The reference b doesn't copy any of m's data—it acts as a lightweight "view" pointing directly to m. When you call b.size() or b.rows(), these methods in MatrixBase delegate to the derived class's implementation (via CRTP), so they access m's data directly. That's why the output correctly reports m's size even though b itself is just a 1-byte interface.

Why Does Eigen Use This Design? #

This approach is critical to Eigen's signature strengths:

• Unmatched Flexibility: MatrixBase is the common base for all Eigen matrix types—including concrete matrices, matrix expressions (like m + m or m.transpose()), and even custom matrix-like types. By accepting a MatrixBase<Derived>&, your function can work with any of these, not just fixed-size Matrix objects.
• Zero-Overhead Performance: Eigen uses expression templates to optimize matrix operations. For example, when you write a = b + c, Eigen doesn't create a temporary matrix for b + c—it generates code that computes the result directly into a. Using MatrixBase<Derived>& lets functions accept these expression objects without forcing them to convert to concrete matrices, preserving the optimization.

If Eigen forced you to pass only concrete Matrix objects, you'd lose both this flexibility and the performance benefits of expression templates.

内容的提问来源于stack exchange，提问作者OnurA