如何编写同时兼容Eigen稠密与稀疏矩阵的C++函数？

Hey Steve, great question—this is a common pain point when working with Eigen's dense and sparse types, but we've got a couple of solid C++14-compatible solutions that avoid duplicate code while respecting each type's unique methods. Let's break this down:

1. The Simplest Fix: Function Overloading #

Instead of fighting with template template parameters or std::conditional_t, leverage Eigen's class hierarchy directly with overloaded functions. This works because Eigen::Matrix inherits from Eigen::MatrixBase, and Eigen::SparseMatrix inherits from Eigen::SparseMatrixBase—the compiler will automatically dispatch to the correct overload based on your input type.

Here's how to implement it:

#include <Eigen/Core>
#include <Eigen/SparseCore>

// Overload for dense matrices (uses MatrixBase-exclusive methods)
template <typename Derived>
typename Derived::PlainObject add(const Eigen::MatrixBase<Derived>& a, const Eigen::MatrixBase<Derived>& b) {
    // Add your dense-specific logic here (e.g., .noalias(), .block(), etc.)
    return (a + b).eval(); // .eval() ensures we return a concrete matrix, not a lazy expression
}

// Overload for sparse matrices (uses SparseMatrixBase-exclusive methods)
template <typename Derived>
typename Derived::PlainObject add(const Eigen::SparseMatrixBase<Derived>& a, const Eigen::SparseMatrixBase<Derived>& b) {
    // Add your sparse-specific logic here (e.g., .pruned(), .coeffRef(), etc.)
    return (a + b).pruned().eval(); // Example: prune tiny coefficients before returning
}

Why This Works #

• No extra type traits required—Eigen's built-in hierarchy does the heavy lifting.
• Each overload can safely use type-exclusive methods without compromising type safety.
• Returning PlainObject (instead of raw auto) avoids Eigen's lazy expression template gotchas (like dangling references if you return an unevaluated expression).

2. Tag Dispatch (For More Complex Scenarios) #

If you need more control over type branching (e.g., handling additional matrix types later), tag dispatch is a flexible alternative. This uses type traits to create "tags" that guide the compiler to the right implementation.

First, define helper type traits:

#include <type_traits>

// Trait to check if a type is a dense Eigen matrix
template <typename T>
struct is_eigen_dense : std::is_base_of<Eigen::MatrixBase<std::decay_t<T>>, std::decay_t<T>> {};

// Trait to check if a type is a sparse Eigen matrix
template <typename T>
struct is_eigen_sparse : std::is_base_of<Eigen::SparseMatrixBase<std::decay_t<T>>, std::decay_t<T>> {};

Then write implementation functions tagged with std::true_type (dense) or std::false_type (sparse):

// Dense implementation
template <typename Derived>
typename Derived::PlainObject add_impl(const Eigen::MatrixBase<Derived>& a, const Eigen::MatrixBase<Derived>& b, std::true_type) {
    return (a + b).noalias().eval(); // Dense-specific optimization
}

// Sparse implementation
template <typename Derived>
typename Derived::PlainObject add_impl(const Eigen::SparseMatrixBase<Derived>& a, const Eigen::SparseMatrixBase<Derived>& b, std::false_type) {
    return (a + b).pruned(1e-9).eval(); // Sparse-specific pruning
}

Finally, the public-facing function that dispatches to the right implementation:

template <typename MatrixType>
auto add(const MatrixType& a, const MatrixType& b) {
    static_assert(is_eigen_dense<MatrixType>::value || is_eigen_sparse<MatrixType>::value,
                  "add() only accepts Eigen dense or sparse matrices");
    using dispatch_tag = std::integral_constant<bool, is_eigen_dense<MatrixType>::value>;
    return add_impl(a, b, dispatch_tag{});
}

Why Your Previous Attempts Failed #

Let's quickly address why template template parameters and std::conditional_t didn't work:

• Template template parameters: Eigen's MatrixBase and SparseMatrixBase are single-parameter templates, but concrete types like Eigen::MatrixXd are multi-parameter templates (scalar, rows, cols). The compiler can't deduce the template template parameter correctly across this mismatch.
• std::conditional_t: This forces the compiler to pick one base type at compile time, not both. So your function would only accept either dense OR sparse matrices, not both—defeating the purpose of a single unified interface.

Key Eigen + C++14 Notes #

• Avoid unevaluated expressions: If you use auto without .eval(), you'll return an Eigen expression template (a lazy computation object) instead of a concrete matrix. This can cause dangling references if the original matrices go out of scope.
• PlainObject is your friend: Derived::PlainObject gives you the concrete matrix type (e.g., Eigen::MatrixXd for dense, Eigen::SparseMatrix<double> for sparse) that's safe to return and store.

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