C++中静态分配不同块大小的块对角矩阵实现问询

需求完全可行，利用C++11及以后的模板元编程、可变参数模板和标准库组件，就能实现符合要求的静态块对角矩阵类型，解决你遇到的两个问题。

核心实现思路 #

• 用可变参数模板接收编译期确定的各块维度Ns...
• 用std::tuple存储不同维度的块矩阵（替代自定义静态链表）
• 通过模板化成员函数实现编译期索引直接访问，或结合std::variant实现运行期索引访问
• 用模板元编程提取指定索引对应的块维度，确保类型安全

完整代码实现 #

#include <tuple>
#include <type_traits>
#include <cstddef>
#include <variant>
#include <stdexcept>

// 辅助模板：提取第I个块的维度
template<size_t I, int... Ns>
struct BlockDim;

template<int First, int... Rest>
struct BlockDim<0, First, Rest...> {
    static constexpr int value = First;
};

template<size_t I, int First, int... Rest>
struct BlockDim<I, First, Rest...> {
    static constexpr int value = BlockDim<I-1, Rest...>::value;
};

// 块对角矩阵主类
template<int... Ns>
class BDmat {
private:
    // 用tuple存储所有块，每个块为对应维度的二维float数组
    std::tuple<float[Ns][Ns]...> m_blocks;

public:
    // --------------------------
    // 编译期索引访问（推荐，类型安全）
    // --------------------------
    template<size_t I>
    constexpr auto operator()() -> float[BlockDim<I, Ns...>::value][BlockDim<I, Ns...>::value]& {
        static_assert(I < sizeof...(Ns), "Block index out of bounds");
        return std::get<I>(m_blocks);
    }

    // --------------------------
    // 运行期索引访问（C++17及以上）
    // --------------------------
    auto operator()(size_t idx) -> std::variant<float[Ns][Ns]...>& {
        return std::apply([idx](auto&... blocks) -> std::variant<float[Ns][Ns]...>& {
            size_t current_idx = 0;
            // 遍历所有块，匹配索引
            auto match_block = [&](auto& block) -> std::variant<float[Ns][Ns]...>& {
                if (current_idx++ == idx) return block;
                throw std::out_of_range("Block index out of bounds");
            };
            // 折叠表达式遍历所有块
            (match_block(blocks), ...);
            // 若索引越界，抛出异常
            throw std::out_of_range("Block index out of bounds");
        }, m_blocks);
    }

    // 获取编译期确定的块总数
    static constexpr size_t block_count() noexcept {
        return sizeof...(Ns);
    }

    // 获取第I个块的编译期维度
    template<size_t I>
    static constexpr int block_dim() noexcept {
        static_assert(I < sizeof...(Ns), "Block index out of bounds");
        return BlockDim<I, Ns...>::value;
    }
};

使用示例 #

int main() {
    BDmat<3,4,7> D;

    // 编译期访问第0个块，类型为float[3][3]
    auto& block0 = D.operator()<0>();
    block0[0][0] = 1.0f;

    // 编译期访问第2个块，类型为float[7][7]
    auto& block2 = D.operator()<2>();
    block2[3][4] = 3.14f;

    // 运行期访问（需C++17，需用std::get提取对应类型）
    try {
        auto& block1 = std::get<float[4][4]>(D(1));
        block1[1][1] = 2.0f;
    } catch (const std::out_of_range& e) {
        // 处理索引越界
    }

    return 0;
}

问题解决说明 #

1. 直接访问块元素：
   通过模板化的operator()<I>()，可以直接通过编译期索引I访问对应块，无需遍历链表；若需要运行期索引，借助std::variant实现类型安全的运行期访问。
2. 符合C++规范：
   用标准库的std::tuple替代自定义静态链表结构，通过模板元编程BlockDim提取编译期维度，完全符合C++标准，没有未定义行为。

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