C++ c++；以模板作为参数的类的成员函数专门化

我正在处理一个模板类数组，它接受另一个模板TRAITS作为参数

template <typename BASE, typename STRUCT>
    class Traits {
    public:
        typedef BASE   BaseType;
        typedef STRUCT Struct;
        // .. More here
     };

template <class TRAITS>
    class Array {
    public:
        typedef TRAITS                          Traits;
        typedef typename Traits::BaseType       BaseType;
        typedef typename Traits::Struct         Struct;

        Struct& operator[](size_t i)
        {
            // access proper member
        }
        // More here...
    };

模板
阶级特征{
公众：
typedef基类型；
类型定义结构；
//……更多
};
模板
类数组{
公众：
类型特征；
typedef typename Traits:：BaseType BaseType；
typedef typename Traits:：Struct Struct；
结构和运算符[]（大小\u t i）
{
//访问适当的成员
}
//这里有更多。。。
};

我想根据Traits:：Struct专门研究数组的操作符[]，但是我一直坚持使用语法。我不确定这是否可能

template <typename B>
    typename Array<Traits<B, RuntimeDefined>>::Struct&
    Array<Traits<B, RuntimeDefined>>::operator[](size_t a_index)
    {
        // Access proper member differently
    }

模板
类型名数组：：结构&
数组：：运算符[]（大小索引）
{
//以不同方式访问适当的成员
}

编译器（g++4.4）抱怨：

In file included from array.cpp:8:
array.h:346: error: invalid use of incomplete type ‘class Array<Traits<N, RuntimeDefined> >’
array.h:26: error: declaration of ‘class Array<Traits<N, isig::RuntimeDefined> >’

数组中包含的文件中的

。cpp:8：
array.h:346:错误：不完整类型“class array”的使用无效
array.h:26:错误：声明“类数组”

编辑

该解决方案基于aaa的提案，如下所示：

        Struct& operator[](size_t i)
        {
            return OperatorAt(i, m_traits);
        }

        template <typename B, typename S>
            inline Struct& OperatorAt(size_t i, const Traits<B, S>&)
            {
                // return element at i
            }

        template <typename B>
            inline Struct& OperatorAt(size_t i, const Traits<B, RuntimeDefined>&)
            {
                // partial specialisation
                // return element at in a different way
            }

Struct&operator[]（大小）
{
返回运算符（i，m_）；
}
模板
内联结构和运算符（大小、常量和）
{
//返回元素在i
}
模板
内联结构和运算符（大小、常量和）
{
//部分专业化
//以不同的方式返回处的元素
}

如果我没有记错的话，您必须专门化整个类。 我没有这样做，而是为特定类创建了参数化的专用函数：

例如：

    Struct& operator[](size_t i)
    {
        return operator_(i, boost::type<TRAITS>());
    }
private:
    template<class B>
    Struct& operator_(size_t i, boost::type<B>); // generic
    Struct& operator_(size_t i, boost::type<A>); // specialized

Struct&operator[]（大小）
{
返回运算符（i，boost:：type（））；
}
私人：
模板
结构和运算符（大小，boost:：type）；//通用的
结构和运算符（大小，boost:：type）；//专业的

---

如果您需要更细粒度的控制，可以使用免费函数、boost:：enable_if、boost:：mpl等。

非常感谢您为解决方案提供了不同的观点。