Question

对不起这个标题，解释起来很困惑，但用例子

会更清楚

在C中，我曾经写过这样的程序：

void createClassA()
{
}

void createClassB()
{
}

typedef struct {
        const char *name;
        void (*create_class)();
} MapList;

MapList mapList[] = {
        {"A", &createClassA},
        {"B", &createClassB },
};

void create(const char *name)
{
        int i=0;
        for (i=0; i < sizeof(mapList) / sizeof(MapList); i++) {
                if (strcmp(name, mapList[i].name) == 0) mapList[i].create_class();
        }
}

int main(int argc, char** argv)
{
        if (argc < 1) return -1;
        create(argv[1]);

        return 0;
}

因此，如果我有更多类型，我所要做的就是创建函数本身并将其添加到mapList。

但在C ++中，我能做的最好就是：

#include <iostream>

class myA{};
class myB{};
class myC{};

class Base
{
public:
        template<class T>
        void createClass()
        {
                T* t = new T();
                //t->doSomethingUseful();
        }

        void create(const std::string name)
        {
                if (name=="A") createClass<myA>();
                else if (name=="B") createClass<myB>();
                else if (name=="C") createClass<myC>();
        }
};

int main(int agrc, char** argv)
{
        if (argc<1) return -1;
        Base b;
        b.create(argv[0]);

        return 0;
}

我可以创建类似的内容：

typedef struct {
   std::string name;
   [CLASS_TYPE] class_type; <== I don't know how
} MapList;

所以我可以创建一个映射List，但用类Type填充它，比如

mapList[] = {
   {"A", myA},
   {"B", myB},
   {"B", myC},
};

然后我可以创建迭代：

for (int i=0; i<sizeof(mapList) / sizeof(MapList); i++) {
   if (mapList[i].name == name) b.createClass<mapList[i].classType>();
}

谢谢你们：）

Answer 1

在C ++中，您可以在<functional>标准标题中使用std::function。具体来说，您的地图列表示例可以写成（使用lambdas）：

std::map<std::string, std::function<void()>> mapList;
mapList["A"] = []() { /* ... */ };
mapList["B"] = []() { /* ... */ };

或只是（没有lambdas）：

void createClassA() {}
void createClassB() {}

std::map<std::string, std::function<void()>> mapList;
mapList["A"] = createClassA;
mapList["B"] = createClassB;

Answer 2

在C ++中，你可以用虚函数来做到这一点：

struct ClassMaker {
    virtual void create_class() = 0;
};
struct ClassMakerA : public ClassMaker {
    virtual void create_class() {
        ...
    }
};
struct ClassMakerB : public ClassMaker {
    virtual void create_class() {
        ...
    }
};

现在您可以使用“工厂”创建std::map<std::string,ClassMaker*>，如下所示：

ClassMakerA makerA;
ClassMakerB makerB;
// This syntax requires C++11
std::map<std::string,ClassMaker*> makers = {
    {"A", &makerA}
,   {"B", &makerB}
};

最后，您现在可以根据create_class()值来调用std::string，如下所示：

void create(const std::string &name) {
    ClassMaker *maker = makers[name];
    if (maker) maker -> create_class();
}

Answer 3

您可以查找Boost::any，它提供“变体值类型”。

Answer 4

您可以使用派生类和对象工厂，这样的工作。您可以通过make create方法返回智能指针并使A和B构造函数为私有来改进它，以避免在堆栈上创建对象。

class Base
{
static Base* create(const char *name);
};

class A : public Base
{
};

class B : public Base
{

};

Base* Base::create(const char *name)
{
if(strcmp(name,"A")==0)
return new A();
if(strcmp(name,"B")==0)
return new B();

return 0;
}

int main(int agrc, char** argv)
{
        if (argc<1) return -1;
        Base *b = Base::create(argv[0]);

        return 0;
}

它有点类似于@dasblinkenlight的解决方案，但避免了虚函数开销。

如何在C ++中执行函数指针，但是对于变量

4 个答案: