int&&& x;   //  非法

template<typename T>
void f(T&& x);

int a;
f(a);       // T = int&

T&& → int& &&   ← 出現(xiàn)“引用的引用”

int&& && x;     // 語(yǔ)法錯(cuò)誤（非模板上下文）

template<typename T>
void f(T&& x);

int a = 10;
f(a);

T = int&
T&& = int& && → 折疊 → int&

f(10);

T = int
T&& = int&&

int a = 10;
auto&& x = a;

auto = int&
auto&& = int& && → int&

auto&& y = 10;

auto = int
auto&& = int&&

auto&&   // 永遠(yuǎn)是萬(wàn)能引用

using LRef = int&;
using RRef = int&&;

LRef&   → int&
LRef&&  → int&
RRef&   → int&
RRef&&  → int&&

int x = 10;

decltype(x)      // int
decltype((x))    // int&   ← 注意括號(hào)！

decltype((x))&& y = x;

decltype((x)) = int&
int& && → int&

template<typename T>
T&& forward(remove_reference_t<T>& param);

template<typename T>
void wrapper(T&& arg) {
    foo(std::forward<T>(arg));
}

T = int&
forward<int&>(arg) → int&

T = int
forward<int>(arg) → int&&

template<typename T>
void f(T&& x);   //  錯(cuò)

void f(int&&&& x);  // 

模板推導(dǎo)
→ 生成候選類型
→ 引用折疊
→ 最終參數(shù)類型
→ 代碼生成

Eigen::Matrix<double, 15, 15> H;
Eigen::Matrix<double, 15, 1>  b;

Eigen::Vector3d r;
Eigen::Matrix3d J;

void AddResidual(Eigen::VectorXd r) {
    // 每次調(diào)用都會(huì)拷貝
}

Matrix = 表達(dá)式

template<typename Derived>
void AddResidual(Eigen::MatrixBase<Derived> r) {
    // 拷貝已經(jīng)發(fā)生
}

template<typename Derived>
void AddResidual(const Eigen::MatrixBase<Derived>& r);

template<typename Derived>
void AddResidual(Eigen::MatrixBase<Derived>&& r) {
    // 完美接收左值 or 右值
}

Eigen::Vector3d r;
AddResidual(r);

T = Eigen::Vector3d&
T&& = Eigen::Vector3d& && → 折疊 → Eigen::Vector3d&

AddResidual(J * dx + r0);

J * dx + r0  → Eigen::CwiseBinaryOp<...>（表達(dá)式）

T = CwiseBinaryOp<...>
T&& = CwiseBinaryOp<...>&&

const Eigen::MatrixBase<Derived>& r

template<typename Derived>
void foo(Eigen::MatrixBase<Derived>&& x);

auto&& expr = std::forward<Derived>(x);

template<typename ResidualDerived, typename JacobianDerived>
void AddFactor(ResidualDerived&& r,
               JacobianDerived&& J) {
    using RType = std::remove_reference_t<ResidualDerived>;
    using JType = std::remove_reference_t<JacobianDerived>;

    // 僅在必要時(shí) eval
    const RType& r_eval = r;
    const JType& J_eval = J;

    // 參與正規(guī)方程
}

AddFactor(
    J * dx + r0,          // 右值表達(dá)式
    J.transpose() * J     // 右值表達(dá)式
);

template<typename TangentDerived>
void ApplyUpdate(TangentDerived&& delta) {
    // delta 是 Eigen::Matrix<double, 6, 1> 或表達(dá)式
    xi_ = Sophus::SE3d::exp(delta) * xi_;
}

Eigen::Matrix<double, 6, 1> dx;
ApplyUpdate(dx);

ApplyUpdate(H.ldlt().solve(b));

template<typename Derived>
void Foo(Derived&& x) {
    Bar(std::forward<Derived>(x));
}

Bar(x);  // 丟失值類別 → 右值變左值

template<typename T>
void func(T&& x);

auto&& v = std::forward<T>(x);

template<typename R, typename J>
void AddResidual(R&& r, J&& J) { ... }

template<typename DX>
void Update(DX&& dx);

template<typename Measurement>
Factor(Measurement&& z);