Class 使用模板外部类中嵌套类的默认模板参数继承

我有一个模板外部类（

外部

下面）和一个公共模板嵌套类（

内部

）。

internal

的模板参数具有默认值。我专门化

Outer

（

SpecializedOuter

），然后从嵌套类（

SpecializedOuter:：Inner

）派生来定义一个新类（

specializedIner

）。如果我在

SpecializedInner

的定义中指定

内部

的模板参数，编译就可以了。但是，如果在

SpecializedInner

中省略

Inner

的模板参数，即使指定了默认值（

Inner

），g++也不会编译代码

有没有办法解决g++和VS2013的问题？我浏览了谷歌搜索结果和其他问题，但在获取能够区分“默认”和“模板”的所有可能用法的搜索词时遇到了困难：）

代码和错误消息 以下

test.cpp

编译时在g++5.4.0上没有错误或警告，

g++-std=c++11-Wall-c test.cpp-o test.o

：

template<typename T>
class Outer {
public:
  template<typename U = void>   // The default I want to take advantage of
  class Inner {
    Outer *outer_;
  public:
    Inner(Outer *outer): outer_(outer) {}
  };
}; //Outer

typedef Outer<int> SpecializedOuter;

class SpecializedInner: public SpecializedOuter::Inner<void> { 
    // also works with int or double instead of void - I just have to specify some type.
public:
  SpecializedInner(SpecializedOuter *so)
    : SpecializedOuter::Inner<void>(so)     // type also expressly specified here
  {}
};

用例

---

如果您想知道，在我的用例中，

Outer

是

osg:：Geometry

的子类，

Inner

是

osg:：Drawable:：UpdateCallback

的子类。为了方便起见，我正在尝试将样板文件移到

内部

，并从

osg:：Geometry

到

外部

删除对

动态转换的需要。发布后，我在中找到了答案。我把它留在这里，以防对其他人有用。使用默认值时，您仍然必须在类名的末尾添加
，以将其从模板名转换为实例化类的名称（根据上述问题）。这将成功编译：

template<typename T>
class Outer {
public:
  template<typename U = void>
  class Inner {
    Outer *outer_;
  public:
    Inner(Outer *outer): outer_(outer) {}
  };
}; //Outer

typedef Outer<int> SpecializedOuter;

class SpecializedInner: public SpecializedOuter::Inner<> { 
    // without <void>, but with <> => OK
public:
  SpecializedInner(SpecializedOuter *so)
    : Inner<>(so)     // without <void>, with <> => OK.  Plus, don't have to
  {}                  // re-specify `SpecializedOuter::`!
};
// vi: set ts=2 sts=2 sw=2 et ai: //

模板
类外部{
公众：
模板
班级内部{
外*外；
公众：
内（外*外）：外（外）{
};
}; //外面的
typedef外部专用外部；
类SpecializedInner:公共SpecializedOuter:：内部{
//没有，但有=>OK
公众：
SpecializedIner（SpecializedOuter*so）
：Inner（so）//without=>OK。另外，不必
{}//重新指定`SpecializedOuter:：`！
};
//vi：设置ts=2 sts=2 sw=2 et ai://

template<typename T>
class Outer {
public:
  template<typename U = void>
  class Inner {
    Outer *outer_;
  public:
    Inner(Outer *outer): outer_(outer) {}
  };
}; //Outer

typedef Outer<int> SpecializedOuter;

class SpecializedInner: public SpecializedOuter::Inner<> { 
    // without <void>, but with <> => OK
public:
  SpecializedInner(SpecializedOuter *so)
    : Inner<>(so)     // without <void>, with <> => OK.  Plus, don't have to
  {}                  // re-specify `SpecializedOuter::`!
};
// vi: set ts=2 sts=2 sw=2 et ai: //