1

在下面的代码中，C 的基类 B1 的模板参数 OFFSET 依赖于 B0，而 B2 依赖于 B1。

这是通过在每次创建 C 实例时手动编写代码来完成的（在 main 方法中）。有没有办法将此功能转移到 C 的定义中？

template<int OFFSET>
struct A {
    enum O { offset = OFFSET };
    enum S { size = 2 };
};

template<int OFFSET>
struct B {
    enum O { offset = OFFSET };
    enum S { size = 4 };
};

template < typename B0, typename B1, typename B2 >
struct C : public B0, B1, B2 {
};

int main(int argc, const char *argv[])
{
    // instance of C
    C< A<1>,

       B< A<1>::offset * A<1>::size >,

       A<
           B< A<1>::offset * A<1>::size >::offset *
           B< A<1>::offset * A<1>::size >::size
       >
    > c1;

    // does the same thing
    C< A<1>,

       B< A<1>::size >,

       A<
           A<1>::size *
           B< A<1>::size >::size
       >
    > c2;

    return 0;
}

编辑：

为了回答评论，我认为需要采取以下步骤来解决这个问题：

  • 编写一个可以改变偏移量的元函数：set_new_offset，它为 T 定义类型 T<2>

  • 使用 boost::mpl::times 计算新的偏移量

  • 添加更多模板魔术...

4

2 回答 2

1

您可以使用 C 中的模板模板来做到这一点，尽管我不是 100% 出售它，但这是一种改进。如果你只需要三个基地，这应该没问题。如果您需要任意数量的碱基......必须有比继承更好的方法来做到这一点，因为这种方法会变得笨拙。

template<int OFFSET>
struct A {
    enum O { offset = OFFSET };
    enum S { size = 2 };
};

template<int OFFSET>
struct B {
    enum O { offset = OFFSET };
    enum S { size = 4 };
};

template < typename B0, template <int T> class B1, template <int T> class B2 >
struct C : public B0, B1<B0::offset * B0::size>, B2<B1<B0::offset * B0::size>::offset * B1<B0::offset * B0::size>::size> {
    enum
    {
        B0_offset = B0::offset,
        B1_offset = B1<B0::offset * B0::size>::offset,
        B2_offset = B2<B1<B0::offset * B0::size>::offset * B1<B0::offset * B0::size>::size>::offset,
        B0_size = B0::size,
        B1_size = B1<B0::offset * B0::size>::size,
        B2_size = B2<B1<B0::offset * B0::size>::offset * B1<B0::offset * B0::size>::size>::size
    };
};

int main()
{
    // instance of C
    C< A<1>,

       B,

       A
    > c1;

    static_cast<void>(c1);

    // does the same thing
    C< A<1>,

       B,

       A
    > c2;

    static_cast<void>(c2);

    std::cout << c1.B0_offset << std::endl;
    std::cout << c1.B1_offset << std::endl;
    std::cout << c1.B2_offset << std::endl;
    std::cout << c1.B0_size << std::endl;
    std::cout << c1.B1_size << std::endl;
    std::cout << c1.B2_size << std::endl;

    std::cout << c2.B0_offset << std::endl;
    std::cout << c2.B1_offset << std::endl;
    std::cout << c2.B2_offset << std::endl;
    std::cout << c2.B0_size << std::endl;
    std::cout << c2.B1_size << std::endl;
    std::cout << c2.B2_size << std::endl;

    return 0;
}
于 2012-01-06T17:45:59.990 回答
1

如何定义一个助手类：

template <template <int> class C, int N>
struct Composer
{
    enum O { offset = C<N>::offset * C<N>::size; };
    enum S { size = C<N>::size; };
};

然后你可以说：

C<A<1>, Composer<A, 1>, Composer<B, Composer<A, 1>::offset> c2;

如果有必要，可以想出一个高阶作曲家，让你形成更高的作曲“力量”。

（也许Composer应该被称为Bind1st左右......）

于 2012-01-06T17:27:24.727 回答