Question

我正在试图找出嵌套模板类的显式特化的正确语法。以下代码将更好地说明：

struct Column_Major;
struct Row_Major;

template<size_t rows, size_t cols, typename T, typename Allocator>
class Matrix
{

    /* bunch of members */
    template <typename storage = Column_Major>
    class Iterator
    {
        /* bunch of members */
    };
};

我想为template <> class Matrix<...>::Iterator<Row_Major编写一个明确的专门化，但语法不在于我。我怀疑如果没有包含类Matrix的显式特化，就不可能明确地专门化Iterator类。但如果有办法，我会很高兴。

我知道我可以使Iterator类成为一个单独的类，而不是Matrix类的成员，但是这样嵌套的类允许我完全访问Matrix的模板参数和数据库类，简化了事情。我知道如果需要，我可以解决这个问题，但我首先想调查并理解嵌套方法的可能性。

谢谢，什穆埃尔

Answer 1

对于显式特化，你需要在内部之前专门化外部类，你可以see this question for example。

有一种使用部分特化的解决方法：

template<size_t rows, size_t cols, typename T, typename Allocator>
class Matrix
{

    //                           Notice the additionnal dummy parameter
    //                                       vvvvvvvvvvvvv
    template <typename storage = Column_Major, bool = true>
    class Iterator
    {
    };

    // Specialization
    template <bool dummy>
    class Iterator<Row_Major, dummy>
    {
    };
};

Answer 2

使用C ++ 11可以让Synxis回答（使用默认的伪参数）更加干净：

/// template <typename X>, not needed for the example
struct Outer
{
private:
    template <typename A, typename D = void>
    struct Inner
    {
        Inner()  { cout << "default" << endl; }
    };
    template <typename D>
    struct Inner<int,D>
    {
        Inner()  { cout << "int" << endl; }
    };  
public:
    template <typename T>
    using  Nested = Inner<T>;
};

这种改进的优点是Nested的签名只有一个模板参数，如果你想在模板元编程中正确匹配它，我认为这将有所帮助。

Answer 3

我很惊讶嵌套类的模板参数不是父类的参数。

嵌套类可以使用父类的模板参数，这将嵌套类更紧密地绑定到父类。你使用迭代器这个词表明这是好的，迭代器肯定会迭代父包含的相同类型吗？

我会这样做：

template <class T>
class Outer
{
public:
    class Inner
    {
        void Fn( T in )
        {
        }
    };
};

// specialisation
void Outer<double>::Inner::Fn( double in )
{

}

嵌套模板类的特化语法

3 个答案: