Question

我有一个模板化的类A<T>，其中包含一个返回foo()的静态方法A<T> *。我有一个子类B，专门用于A<int>。

为避免代码重复，我希望B能够利用A的静态foo()方法。但是，以下内容会出现编译错误：error: cannot initialize return object of type 'B *' with an rvalue of type 'A<int> *')但B *正好是A<int> *，不是吗？

B有办法使用A＆＃39; foo()方法吗？

template <typename T>
class A {
public:
  static A *foo() {
    // imagine complex code here
    return new A<T>();
  }
};

// B is a typed specialization of A
class B : public A<int> {
public:
  static B *foo() {
    return A<int>::foo();    // doesn't compile
  }
};

int main() {
  B *b = B::foo();
  (void)b;                      // suppress unused variable warning
}

Answer 1

有没有办法创建一个类B，当我使用它时，意味着A<int>？

如果B是A<int>的别名，那么它是A<int>的别名，B::foo和A<int>::foo是同一个东西，你真正想要的是A<int>::foo与香草A<T>::foo相比做一些额外的事情，但仍然重复使用A<T>::foo的代码。

换句话说，您需要对该成员函数进行显式特化。要重用代码的vanilla版本，只需将公共代码移动到单独的函数中：

template<class T>
struct A {
    static A<T> * foo_common() { 
        // common stuff 
        return nullptr;     
    }

    static A<T> * foo() { 
        // vanilla foo(); just call foo_common()
        return foo_common(); 
    }
};

// specialization of `foo` for A<int>
template<>
inline A<int>* A<int>::foo() { 
    auto p = foo_common(); 
    // extra stuff
    return p;
}

如果您希望B表示A<int>，那就很简单：

using B = A<int>;

调用模板化超类的静态方法

1 个答案: