如何惯用地调用 C++基于变量值的函数？

Question

假设我有一个数据类型enum TreeTypes { TallTree, ShortTree, MediumTree }。

我必须根据一种特定的树类型初始化一些数据。

目前我已经编写了这段代码：

int initialize(enum TreeTypes tree_type) {
    if (tree_type == TallTree) {
        init_tall_tree();
    }
    else if (tree_type == ShortTree) {
        init_short_tree();
    }
    else if (tree_type == MediumTree) {
        init_medium_tree();
    }
    return OK;
}

但这是某种愚蠢的代码重复。我没有使用任何强大的 C++ 功能，例如模板。

我怎样才能更好地编写这段代码？

谢谢，博达·西多。

Answer 1

您的代码对于两个或三个值来说是可以的，但是您是对的，当您有数百个值时，您需要更具工业强度的东西。两种可能的解决方案：

• 使用类层次结构，而不是枚举 - 然后您可以使用虚函数并让编译器确定要调用哪个实际函数

• 创建枚举映射 ->函数，您在启动时初始化 - 您的函数调用将变成类似 map[enum]->func()

模板在这里效果不佳，因为您试图在以下位置做出决定运行时，而模板在编译时完成它们的工作。

Answer 2

一言以蔽之：继承

class Tree { public: virtual void initialize() = 0; }

class ShortTree : public Tree {
public:
    virtual void initialize(){
        /* Short Tree specific code here */
    }
}

class MediumTree : public Tree {
public:
    virtual void initialize(){
        /* Medium Tree specific code here */
    }
}

class TallTree : public Tree {
public:
    virtual void initialize(){
        /* Tall Tree specific code here */
    }
}

然后无论你想在哪里调用初始化，只需确保有一个指针或引用以使多态性正常工作：

Vector<Tree*> trees;
trees.push_back(new SmallTree());
trees.push_back(new MediumTree();
trees.push_back(new TallTree();

// This will call the tree specific code for each tree in the vector
for(vector<Tree*>::iterator tree = trees.begin(); tree!=trees.end(); ++tree)
    tree->initialize();

Answer 3

使用由枚举值索引的查找表（假设所有函数具有相同的签名），即：

enum TreeTypes { TallTree, ShortTree, MediumTree, MaxTreeTypes }

typedef void (*p_init_func)(void); 

p_init_func initialize_funcs[MaxTreeTypes] =
{
    &init_tall_tree, 
    &init_short_tree,
    &init_medium_tree
};

int initialize(enum TreeTypes tree_type)
{ 
    initialize_funcs[tree_type]();
    return OK; 
} 

Answer 4

以及模板方式，因为您已经在标签中指出了它：

enum TreeTypes { Tall, Short, Medium };

struct TreeBase {
    // (...)
};

struct TallTree : public TreeBase {
    // (...)
};

struct ShortTree : public TreeBase {
    // (...)
};

struct MediumTree : public TreeBase {
    // (...)
};

template<TreeTypes N_type = Tall>
struct Tree : public TallTree {
    // (...)
};

template<>
struct Tree<Short> : public ShortTree {
    // (...)
};

template<>
struct Tree<Medium> : public MediumTree {
    // (...)
};

这样您就可以为每种树类型获得单独的类，可以通过基指针访问这些类。将它们包装到 Tree 类中可以让您执行以下操作：

Tree<Tall> tall_tree;
Tree<Short> short_tree;
Tree<Medium> medium_tree;

Answer 5

如果这个初始化确实是唯一的区别，那么我不确定任何其他习惯用法会改善这种情况。

您可以从 Tree 继承并创建正确类型的树对象...但是您仍然需要区分要实例化的树对象，因此您仍然会在某处得到类似的 if/else 块。

也就是说，如果不仅仅是初始化不同，您应该子类化并使用虚函数来体现它们之间的差异。

Answer 6

尝试使用 switch 语句：

int initialize(enum TreeTypes tree_type) {
    switch (tree_type) {
        case TallTree: 
            init_tall_tree();
            break;
        case ShortTree:
            init_short_tree();
            break;
        case MediumTree:
            init_medium_tree();
            break;
    }
    return OK;
}