C++ 创建成员函数名并在运行时在c++；

有人能告诉我这个问题的答案吗。我在互联网上搜索过这方面的信息，但无法获得我想要的更多信息

假设有一节课

class Foo {
  explicit Foo() {}

  int getVar1();
  int getVar2();

  void setVar1(int v);
  void setVar2(int v);

  private:
  int var1, var2;
};

现在给出一个标记列表{“var1”、“var2”、…“varN”}，有没有办法在运行时创建函数名并调用Foo类型的某个对象的成员函数。比如说

Foo obj;
string input = "Var1,Var2,Var3,...VarN";
vector<string> tokens = splitString(input);
for (vector<string>::const_iterator it = tokens.begin(); it != tokens.end(); ++it) {
  string funName = "get" + *it;
  // somehow call obj.getVar1()....obj.getVarN()
}

Foo-obj；
字符串输入=“Var1，Var2，Var3，…VarN”；
向量标记=拆分字符串（输入）；
for（vector:：const_iterator it=tokens.begin（）；it！=tokens.end（）；+it）{
string funName=“get”+*it；
//以某种方式调用obj.getVar1（）…obj.getVarN（）
}

使用if-else可以处理少量变量，但不适合处理大量变量。使用绑定和函子也不能解决这个问题。一个网页建议让内存在运行时可执行，然后使用reinterpret_cast，我不知道这是否可行

更新

< >从互联网上的答案和其他搜索，我看到C++中没有这样的优雅方式。目前C++中没有反射。所有的黑客都需要对成员函数指针进行编译时解析。 当你有很多变量、设置器和吸收器功能时，有人能给我一些关于备选类设计的想法吗？或者在C++中，GET和Stter是好的实践吗？

< P>你不能在运行时“添加”成员。C++在编译时是强类型的。 通过使用

映射

并使用它将字符串解析为实际函数，可以获得所需的行为。您可以使用宏来创建它，以确保字符串名称与函数名称匹配

#DEFINE ADD_METHOD(map_var, func) map_var["func"] = &func

您不能在运行时“添加”成员。C++在编译时是强类型的。 通过使用

映射

并使用它将字符串解析为实际函数，可以获得所需的行为。您可以使用宏来创建它，以确保字符串名称与函数名称匹配

#DEFINE ADD_METHOD(map_var, func) map_var["func"] = &func

---

一个简单/不完美的解决方案可能是使用中间方法检查参数并相应地调用getVar*方法

像这样的例子可能是：

class Foo 
{
public:
    explicit Foo() {}

    int getVar1() { return 1; }
    int getVar2() { return 2; }

    void setVar1(int v) { var1 = v; }
    void setVar2(int v) { var2 = v; }

    int callGetVar(const std::string &var)
    {
        if (var == "Var1") return getVar1();
        if (var == "Var2") return getVar2();
        else { return -1; }
    }

private:
    int var1, var2;
};

int main()
{
    Foo obj;
    std::string input = "Var1,Var2,Var3,...VarN";
    std::vector<std::string> tokens = { "Var1", "Var2", "Var2", "Var1", "Var1", "Var2", "Var2", "Var1"};
    auto tokensIT = tokens.begin();
    for (; tokensIT != tokens.end(); ++tokensIT) 
    {
        // somehow call obj.getVar1()....obj.getVarN()
        std::cout << obj.callGetVar(*tokensIT);
    }

    return 0;
}

class-Foo
{
公众：
显式Foo（）{}
int getVar1（）{return 1；}
int getVar2（）{return 2；}
void setVar1（int v）{var1=v；}
void setVar2（int v）{var2=v；}
int callGetVar（const std:：string&var）
{
if（var==“Var1”）返回getVar1（）；
if（var==“Var2”）返回getVar2（）；
else{return-1；}
}
私人：
int-var1，var2；
};
int main（）
{
富奥比；
std:：string input=“Var1，Var2，Var3，…VarN”；
向量标记={“Var1”、“Var2”、“Var2”、“Var1”、“Var1”、“Var2”、“Var2”、“Var2”、“Var1”}；
auto-tokensIT=tokens.begin（）；
for（；tokensIT！=tokens.end（）；++tokensIT）
{
//以某种方式调用obj.getVar1（）…obj.getVarN（）
std:：cout一个简单/不完美的解决方案可以是使用一个中间方法检查参数并相应地调用getVar*方法

像这样的例子可能是：

class Foo 
{
public:
    explicit Foo() {}

    int getVar1() { return 1; }
    int getVar2() { return 2; }

    void setVar1(int v) { var1 = v; }
    void setVar2(int v) { var2 = v; }

    int callGetVar(const std::string &var)
    {
        if (var == "Var1") return getVar1();
        if (var == "Var2") return getVar2();
        else { return -1; }
    }

private:
    int var1, var2;
};

int main()
{
    Foo obj;
    std::string input = "Var1,Var2,Var3,...VarN";
    std::vector<std::string> tokens = { "Var1", "Var2", "Var2", "Var1", "Var1", "Var2", "Var2", "Var1"};
    auto tokensIT = tokens.begin();
    for (; tokensIT != tokens.end(); ++tokensIT) 
    {
        // somehow call obj.getVar1()....obj.getVarN()
        std::cout << obj.callGetVar(*tokensIT);
    }

    return 0;
}

class-Foo
{
公众：
显式Foo（）{}
int getVar1（）{return 1；}
int getVar2（）{return 2；}
void setVar1（int v）{var1=v；}
void setVar2（int v）{var2=v；}
int callGetVar（const std:：string&var）
{
if（var==“Var1”）返回getVar1（）；
if（var==“Var2”）返回getVar2（）；
else{return-1；}
}
私人：
int-var1，var2；
};
int main（）
{
富奥比；
std:：string input=“Var1，Var2，Var3，…VarN”；
向量标记={“Var1”、“Var2”、“Var2”、“Var1”、“Var1”、“Var2”、“Var2”、“Var2”、“Var1”}；
auto-tokensIT=tokens.begin（）；
for（；tokensIT！=tokens.end（）；++tokensIT）
{
//以某种方式调用obj.getVar1（）…obj.getVarN（）
STD：：CUT
作为一个想法，考虑下面的代码
struct A
{
    void f1() { std::cout << "A::f1()\n"; }
    void f2() { std::cout << "A::f2()\n"; }
    void f3() { std::cout << "A::f3()\n"; }
    void f4() { std::cout << "A::f4()\n"; }
};

std::map<std::string, void( A::* )()> m = { { "f1", &A::f1 }, { "f2", &A::f2 }, { "f3", &A::f3 }, { "f4", &A::f4 } };

A a;

for ( auto p : m ) ( a.*p.second )();

结构A
{
空f1（{STD::CUT
）作为一个想法考虑下面的代码
struct A
{
    void f1() { std::cout << "A::f1()\n"; }
    void f2() { std::cout << "A::f2()\n"; }
    void f3() { std::cout << "A::f3()\n"; }
    void f4() { std::cout << "A::f4()\n"; }
};

std::map<std::string, void( A::* )()> m = { { "f1", &A::f1 }, { "f2", &A::f2 }, { "f3", &A::f3 }, { "f4", &A::f4 } };

A a;

for ( auto p : m ) ( a.*p.second )();

结构A
{
void f1（）{std:：cout为什么不以引用的方式查看它：
为每个变量指定一个索引号，从0、1、2开始。。。。
将这些值保存在映射中（键是变量名，值是赋值）。
这些变量的所有值都保存在一个数组中，因此第一个变量的值在单元格0中，下一个变量的值在单元格1中，以此类推

因此，当您想要获取/设置值时，您需要做的就是在映射中找到它的索引，并访问向量中的相关单元格。
为什么不以引用的方式查看它：
为每个变量指定一个索引号，从0、1、2开始。。。。
将这些值保存在映射中（键是变量名，值是赋值）。
这些变量的所有值都保存在一个数组中，因此第一个变量的值在单元格0中，下一个变量的值在单元格1中，以此类推

当你想要获得/设置值时，你需要做的就是在地图中找到它的索引，并在向量中访问相关的单元。< /P>你不能在C++中这样做，但是你可以用一个次优的方式得到等价的功能。你可以看看我写了一个工具，它帮助你根据你的类生成反射代码：你不能在C++中这样做。但是，您可以以次优的方式获得等效的功能。您可能会看到，我编写了一个工具，帮助您根据类生成反射代码：我想在我的帖子中附加一个选项，您可以将映射作为Classic的静态数据成员。我想在我的帖子中附加一个选项，您可以将映射作为静态数据成员你们班的学生