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

我有一个模板类

a

，它包含一个静态方法

foo（）

，该方法返回一个

a*

。我有一个子类

B

，它专门用于

a

为了避免代码重复，我希望B利用A的静态

foo（）

方法。但是，下面的代码会出现编译错误：

错误：无法用类型为“a*”的右值初始化类型为“B*”的返回对象。

但是

B*

正好是

a*

，不是吗

B有没有办法使用a的

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
}

模板
甲级{
公众：
静态A*foo（）{
//想象一下这里的复杂代码
返回新的A（）；
}
};
//B是a的类型化专门化
B类：公共A{
公众：
静态B*foo（）{
返回A:：foo（）；//未编译
}
};
int main（）{
B*B=B:：foo（）；
（void）b；//抑制未使用的变量警告
}

有没有办法创建一个类

B

，当我使用它时，它的意思是

a

如果

B

是

A

的别名，那么它就是

A

的别名，

B:：foo

和

A:：foo

是一回事，你真正想要的是

A:：foo

比普通的

A:：foo

做一些额外的事情，但仍然重用

A:：foo

的代码

换句话说，您需要该成员函数的显式专门化。要重用普通版本的代码，只需将通用代码移动到单独的函数：

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的静态foo（）方法

，

A:：foo（）

是公共的，为什么要在

B

中复制它？因为我省略了细节以保持示例简单：

B:：foo（）

对

A:：foo（）

返回的对象做了一些额外的操作“但是B*就是A*，不是吗？”好吧，不是！一点也不<代码>B不是

a

的专业化

A

是

B

的专业化

B

是从

a

继承的类。这是一种独特的类型。

using B = A<int>;