Question

我有一个纯虚函数，它在基类中返回std :: array。我希望此数组的大小取决于派生类中的类型。我尝试了以下方法，但由于类型不完整，似乎编译器无法解析模板。

template<typename T>
struct base
{
    virtual std::array<int, T::SIZE> foo(void) = 0;
};

struct derived : public base<derived>
{
    enum 
    {
        SIZE = 5
    };
    std::array<int, derived::SIZE> foo(void) 
    {
        return std::array<int, derived::SIZE>{1,2,3,4,5};
    };
};

在实例化“ struct base”时： 12:25：从这里需要 9:38：错误：嵌套名称说明符中使用了不完整的类型“派生”

我也尝试过做类似类型特征的操作，但是我又得到了不完整的类型，在这种情况下，这是有道理的，因为模板专业化需要类在完成专业化之前实际完成。

template<typename T>
struct sizeTrait;

template<typename T>
struct base
{
    virtual std::array<int, sizeTrait<T>::SIZE> foo(void) = 0;
};

struct derived : public base<derived>
{
    std::array<int, sizeTrait<derived>::SIZE> foo(void) 
    {
        return std::array<int, sizeTrait<derived>::SIZE>{1,2,3,4,5};
    };
};

template<>
struct sizeTrait<derived>
{
    enum
    {
        SIZE = 5
    };
};

有人对如何实现这样的目标有任何想法吗？如果可能的话，我不想诉诸宏。我计划有许多不同类型的派生类，这些派生类都继承基类，但是foo将根据在自己的类中定义的枚举（或其他某种类型）返回不同大小的std :: array。另外，我知道我可以使用std :: vector，但是由于输出的大小已经确定，因此我想使用数组来完成此操作。

编辑：

建议使用base中的模板参数来确定数组大小。

#include <array>

template<typename T, size_t S>
struct base
{
    using array_type = std::array<int, S>;
    virtual array_type foo() = 0;
};

struct derived : public base<derived, 5>
{
    array_type foo() override
    {
        return array_type {1, 2, 3, 4, 5};
    };
};

但是，我还有另一个模板类，该类将派生作为模板参数，它需要具有相同大小的数组。

template<typename DerivedClass>
struct other
{
    std::array<int, DerivedClass::SIZE> array_;
};

在这种情况下，我希望基于DerivedClass的实际大小来确定array_的大小。有没有办法解决DerviedClass :: SIZE为5？也许通过像DerivedClass :: base :: array_type这样的模板参数DerivedClass访问基址？

Answer 1

尝试sizeTrait时，只需将其定义移到derived中即可。您可以使用derived的前向声明来完成此操作：

template<typename T>
struct sizeTrait;

template<typename T>
struct base
{
    virtual std::array<int, sizeTrait<T>::SIZE> foo(void) = 0;
};

struct derived;

template<>
struct sizeTrait<derived>
{
    enum
    {
        SIZE = 5
    };
};

struct derived : public base<derived>
{
    std::array<int, sizeTrait<derived>::SIZE> foo(void) 
    {
        return std::array<int, sizeTrait<derived>::SIZE>{1,2,3,4,5};
    }
};

Answer 2

为什么不将size作为基础模板参数？

#include <array>

template<typename T, size_t S>
struct base
{
    using array_type = std::array<int, S>;
    virtual array_type foo() = 0;
};

struct derived : public base<derived, 5>
{
    array_type foo() override
    {
        return array_type {1, 2, 3, 4, 5};
    }
};

更新以回答使用derived从类访问数组类型（或大小）的问题。您可以访问以下类型：

template<class T>
struct another
{
    using array_type = typename T::array_type;

    array_type bar()
    {
        return array_type {1, 2, 3, 4, 5};
    }

    static constexpr size_t size()
    {
        // Returns 5
        return std::tuple_size<array_type>();
    }
};

使用模板确定std :: array大小CRTP

2 个答案: