C 11模板变量设计

如果您可以列出所有派生类型：

信头：

struct Letter {
    enum LetterEnum {LetterA,LetterB,LetterC,LetterCount};

    virtual ~Letter() {} //base types should always have virtual destructor
    virtual void foo() = 0;

    static std::unique_ptr<Letter> construct(LetterEnum c);
};

实施标题：

struct A : Letter {
  void foo() override;
};

struct B : Letter {
  void foo() override;
};

struct C : Letter {
  void foo() override;
};

信体：

std::unique_ptr<Letter> Letter::construct(Letter::LetterEnum c) 
{
    switch(c) {
    case Letter::LetterA : return make_unique<A>();
    case Letter::LetterB : return make_unique<B>();
    case Letter::LetterC : return make_unique<C>();
    default: throw ...;
    }
}

用法：

int main() {
    char c;
    std::cin >> c;
    //get a letter of the derived type associated with the letter entered
    std::unique_ptr<Letter> ptr = Letter::construct(c);    
}

如果您无法列出所有派生类型：

允许派生类型使用Letter类注册自己,然后Letter可以使用它来创建每个派生类型.这样,添加和删除派生类型不会更改任何其他文件.简单！

struct Letter {
    virtual ~Letter() {} //destructor is always virtual when inheretence is involved
    ....
    //this is a "shared" function in the Letter class itself
    //it takes a letter,and returns a dynamically allocated instance
    //of the derived type corresponding with that letter
    static std::unique_ptr<Letter> construct(char c);
    //this typedef represents the actual function that returns 
    //each dynamically allocated derived type
    typedef std::function<std::unique_ptr<Letter>()> letter_ctor;
    //this is a "shared" function in the Letter class itself
    //it takes a letter,and a function that creates derived types,//and saves them inside the container ctors
    static bool register(char c,letter_ctor func);
private:
    //this is a "shared" member in the Letter class.  
    //There is only one shared by all of the Letters.  Like a global.
    //When you give it a letter,it gives you a function.
    //and is VERY fast for large numbers of entries
    static std::unordered_set<char,letter_ctor> ctors;
};

并在您的实现文件中：

//here's the function that derived types register themselves with
//pretty straightforward,just inserts the pair into the unordered_map
bool Letter::register(char c,Letter::letter_ctor func)
{return Letter::ctors.insert(std::make_pair(c,std::move(func))).second;}

//and here's the function that creates the derived types
//it checks if the letter is in the unordered_map
//if the letter isn't there,it throws an exception
//otherwise,it calls the function associated with that letter
//which creates the derived type on the heap,and returns a pointer to it
std::unique_ptr<Letter> Letter::construct(char c) 
{
     auto it = Letter::ctors.find(c);
     if (it == Letter::ctors.end())
         throw ...;
     return it->second(); //construct that letter
}

然后你的派生类型执行此操作：

//you know this part
struct LetterA : public Letter 
{
   ....
};
//derived types have to register themselves:
//this is a global,so when the program loads,it automatically calls this
//even before main runs*
//it registers the letter 'A' and a function that creates a LetterA class on the heap
static bool registerA = Letter::register('A',[](){return make_unique<LetterA>();});

然后你可以轻松创建arbirary派生类型！

int main() {
    char c;
    std::cin >> c;
    //get a letter of the derived type associated with the letter entered
    std::unique_ptr<Letter> ptr = Letter::construct(c);
}

*它并不总是在main之前被调用.如果你有问题,请加一个bool init_A();在A头文件中,并在A实现文件中bool init_A(){return true;},并在主文件中有静态bool AInit = init_A();应该强迫它.但这在实践中几乎从不需要.

作为旁注,这些取决于有一个make_unique,它应该在C 11中,但由于疏忽而被遗漏.它将在C 14中.与此同时,使用：

template<class T,class...Us>
std::unique_ptr<T> make_unique(Us&&...us) 
{return std::unique_ptr<T>(new T(std::forward<Us>(us)...));}