如何像C++中的函数指针一样，但针对变量

how to do function pointer like in C++, but for variable

本文关键字：一样 变量 C++ 何像 函数 指针      更新时间：2023-10-16

对不起标题，解释起来很困惑，但通过示例会更清楚

在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;

所以我可以创建一个映射列表，但用类类型填充它，类似

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>();
}

谢谢大家：）

在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;

在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}
};

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

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

您可以查找Boost::any，它提供了"可变值类型"。

您可以使用派生类和对象工厂，这样就可以了。您可以通过使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的解决方案有些相似，但避免了虚拟函数开销。

相关文章：