C++ 如何模板静态工厂方法？

如何模板下面的代码？ 首先，我有一本书作为基础：

class Book {
public:
    Book() {}
    ~Book() {}
}

然后是电脑书：

class ComputerBook: public Book {
public:
    static ComputerBook* create() {
        return new ComputerBook();
    } 
private:
    ComputerBook ():Book() {}
}

然后是电话簿：

class PhoneBook: public Book {
public:
    static PhoneBook* create() {
        return new PhoneBook();
    } 
private:
    PhoneBook():Book() {}
}

电话簿有两种继承：

class PhoneBook1: public PhoneBook {
public:
    static PhoneBook1* create() {
        return new PhoneBook1();
    } 
private:
    PhoneBook1():PhoneBook() {}
}


class PhoneBook2: public PhoneBook {
public:
    static PhoneBook2* create() {
        return new PhoneBook2();
    } 
private:
    PhoneBook2():PhoneBook() {}
}

---

这样就可以将ComputerBook和PhoneBook1、PhoneBook2合并为一个模板？

从您试图做的事情来看，您正在为您的所有书籍创建一个名为

create

的静态工厂方法。您可以按如下方式模板化此方法：

class Book {
public:
    Book() {}
    ~Book() {}
    template<typename T>
    static Book* create() {
        return new T();
    }
}

教材{
公众：
书籍（）{}
~Book（）{}
模板
静态书本*create（）{
返回新的T（）；
}
}

然后制作电话簿：

Book::create<PhoneBook1>();

Book:：create（）；

还要确保每本书的构造函数都是公共的，或者是

Book:：create

静态方法的朋友。

您想要的是（可能是）。在基类中定义方法

create

，在基类中使用作为模板参数的派生类对其进行参数化。从模板库继承时，插入派生类并神奇地获得类型正确的

create

函数

我不明白为什么你有一个私有构造函数，或者为什么你需要这个工厂函数

template < typename Derived >
class Book {
  friend Derived;
public:
  Book() {}
  ~Book() {}
  static Derived* create() {
    return new Derived{};
  }
};

class ComputerBook: public Book<ComputerBook> {
  // Make the base class a friend so we can access the private constructor
  friend class Book<ComputerBook>;
private:
  ComputerBook() : Book() {}
};

template < typename Derived >
class PhoneBook: public Book<Derived> {}; // no private constructor, no 'friend' needed

class PhoneBook1: public PhoneBook<PhoneBook1> {};
class PhoneBook2: public PhoneBook<PhoneBook2> {};

int main()
{
  auto cb = ComputerBook::create();
  auto pb1 = PhoneBook1::create();
  auto pb2 = PhoneBook2::create();
  delete cb;
  delete pb1;
  delete pb2;
}

模板
课堂用书{
朋友衍生；
公众：
书籍（）{}
~Book（）{}
静态派生*create（）{
返回新的派生{}；
}
};
班级计算机图书：公共图书{
//让基类成为朋友，这样我们就可以访问私有构造函数
朋友类书籍；
私人：
ComputerBook（）：Book（）{}
};
模板
类别电话簿：公用电话簿{}；//没有私有构造函数，不需要“朋友”
电话簿1类：公共电话簿{}；
电话簿2类：公共电话簿{}；
int main（）
{
自动cb=ComputerBook:：create（）；
auto pb1=PhoneBook1:：create（）；
auto pb2=PhoneBook2:：create（）；
删除cb；
删除pb1；
删除pb2；
}

返回新的WhateverBook（）

为什么不使用常规构造函数呢？此外，对于这种类型的问题，您不需要模板。继承和虚函数就足够了。也许你是对的。我只是在想是否可以将模板应用到它上。我觉得把它变成模板很不舒服。现在还不清楚您想用这段代码做什么，因为它在很多方面都是矛盾和错误的。应用模板会让事情变得更糟。我看不出这个答案有什么不对。有人能解释一下吗？这个愚蠢的工厂功能本来就不应该存在。不必要地在顶部添加多态性只会使情况变得更糟。