C++；通过字符串调用函数，比较与PHP的性能，如何在C++；？ 我将编写一个程序，让我们在C++中用字符串调用函数。但是，我在PHP中编写了一个程序，但是PHP只花了4秒完成了执行，但是C++完成了27到28秒。 我想知道为什么PHP比C++快得多，以及如何优化C++代码。

另外，我使用的是qtapi，因此带有前缀“Q”的类名（如QHash、QObject）是来自Qt的类

这是我的代码：

C++代码： 类标题定义：

// function_dispatcher.h

#ifndef FUNCTIONDISPATCHER_H
#define FUNCTIONDISPATCHER_H

#include <QObject>
#include <QHash>
#include <functional>

class FunctionDispatcher : public QObject
{
    Q_OBJECT
public:
    FunctionDispatcher(QObject* parent = 0);
    int functionDispatcher(QString functionName, int dataA, int dataB);
    int function1(int a, int b);
    int function2(int a, int b);
    int function3(int a, int b);
    int function4(int a, int b);
    int function5(int a, int b);
    int function6(int a, int b);
    int function7(int a, int b);
    int function8(int a, int b);
    int function9(int a, int b);
    int function10(int a, int b);
    void functionTable();
private:
    QHash<QString, std::function<int(int, int)>> m_functionsTable;
};

#endif // FUNCTIONDISPATCHER_H

#include "functiondispatcher.h"
#include <QDebug>
#include <functional>

#define ADD_FUNCTION(_functionName, _function) m_functionsTable.insert(_functionName, std::bind(_function, this, std::placeholders::_1, std::placeholders::_2));

FunctionDispatcher::FunctionDispatcher(QObject *parent)
    : QObject(parent)
{
        functionTable();
}

int FunctionDispatcher::functionDispatcher(QString functionName, int dataA, int dataB)
{
    std::function<int(int, int)> func = m_functionsTable.value(functionName);
    int result = 0;
    try {
            result = func(dataA, dataB);
    }
    catch(const std::bad_function_call& e) {
            qDebug() << e.what();
    }

    return result;
}

int FunctionDispatcher::function1(int a, int b)
{
    return a + b;
}

int FunctionDispatcher::function2(int a, int b)
{
    return a * b;
}

int FunctionDispatcher::function3(int a, int b)
{
    return a / b;
}

int FunctionDispatcher::function4(int a, int b)
{
    return (a+12) * b;
}

int FunctionDispatcher::function5(int a, int b)
{
    return (a+1) * b;
}

int FunctionDispatcher::function6(int a, int b)
{
    return (a+2221) * b;
}

int FunctionDispatcher::function7(int a, int b)
{
    return (a+31) * b;
}

int FunctionDispatcher::function8(int a, int b)
{
    return (a+11) * b;
}

int FunctionDispatcher::function9(int a, int b)
{
    return (a+141) * b;
}

int FunctionDispatcher::function10(int a, int b)
{
    return (a+12) * b;
}

void FunctionDispatcher::functionTable()
{
    ADD_FUNCTION("function1", &FunctionDispatcher::function1);
    ADD_FUNCTION("function2", &FunctionDispatcher::function2);
    ADD_FUNCTION("function3", &FunctionDispatcher::function3);
    ADD_FUNCTION("function4", &FunctionDispatcher::function4);
    ADD_FUNCTION("function5", &FunctionDispatcher::function5);
    ADD_FUNCTION("function6", &FunctionDispatcher::function6);
    ADD_FUNCTION("function7", &FunctionDispatcher::function7);
    ADD_FUNCTION("function8", &FunctionDispatcher::function8);
    ADD_FUNCTION("function9", &FunctionDispatcher::function9);
    ADD_FUNCTION("function10", &FunctionDispatcher::function10);
}

//函数\u dispatcher.h
#ifndef功能调度器
#定义函数调度程序
#包括
#包括
#包括
类FunctionDispatcher:公共QObject
{
Q_对象
公众：
FunctionDispatcher（QObject*parent=0）；
int-functionDispatcher（QString-functionName、int-dataA、int-dataB）；
内部功能1（内部a、内部b）；
内部功能2（内部a、内部b）；
内部功能3（内部a、内部b）；
内部功能4（内部a、内部b）；
内部功能5（内部a、内部b）；
内部功能6（内部a、内部b）；
内部功能7（内部a、内部b）；
内部功能8（内部a、内部b）；
内部功能9（内部a、内部b）；
内部功能10（内部a、内部b）；
void functionTable（）；
私人：
QHash m_函数稳定；
};
#endif//FUNCTIONDISPATCHER\u H

类别主体定义：

// function_dispatcher.h

#ifndef FUNCTIONDISPATCHER_H
#define FUNCTIONDISPATCHER_H

#include <QObject>
#include <QHash>
#include <functional>

class FunctionDispatcher : public QObject
{
    Q_OBJECT
public:
    FunctionDispatcher(QObject* parent = 0);
    int functionDispatcher(QString functionName, int dataA, int dataB);
    int function1(int a, int b);
    int function2(int a, int b);
    int function3(int a, int b);
    int function4(int a, int b);
    int function5(int a, int b);
    int function6(int a, int b);
    int function7(int a, int b);
    int function8(int a, int b);
    int function9(int a, int b);
    int function10(int a, int b);
    void functionTable();
private:
    QHash<QString, std::function<int(int, int)>> m_functionsTable;
};

#endif // FUNCTIONDISPATCHER_H

#include "functiondispatcher.h"
#include <QDebug>
#include <functional>

#define ADD_FUNCTION(_functionName, _function) m_functionsTable.insert(_functionName, std::bind(_function, this, std::placeholders::_1, std::placeholders::_2));

FunctionDispatcher::FunctionDispatcher(QObject *parent)
    : QObject(parent)
{
        functionTable();
}

int FunctionDispatcher::functionDispatcher(QString functionName, int dataA, int dataB)
{
    std::function<int(int, int)> func = m_functionsTable.value(functionName);
    int result = 0;
    try {
            result = func(dataA, dataB);
    }
    catch(const std::bad_function_call& e) {
            qDebug() << e.what();
    }

    return result;
}

int FunctionDispatcher::function1(int a, int b)
{
    return a + b;
}

int FunctionDispatcher::function2(int a, int b)
{
    return a * b;
}

int FunctionDispatcher::function3(int a, int b)
{
    return a / b;
}

int FunctionDispatcher::function4(int a, int b)
{
    return (a+12) * b;
}

int FunctionDispatcher::function5(int a, int b)
{
    return (a+1) * b;
}

int FunctionDispatcher::function6(int a, int b)
{
    return (a+2221) * b;
}

int FunctionDispatcher::function7(int a, int b)
{
    return (a+31) * b;
}

int FunctionDispatcher::function8(int a, int b)
{
    return (a+11) * b;
}

int FunctionDispatcher::function9(int a, int b)
{
    return (a+141) * b;
}

int FunctionDispatcher::function10(int a, int b)
{
    return (a+12) * b;
}

void FunctionDispatcher::functionTable()
{
    ADD_FUNCTION("function1", &FunctionDispatcher::function1);
    ADD_FUNCTION("function2", &FunctionDispatcher::function2);
    ADD_FUNCTION("function3", &FunctionDispatcher::function3);
    ADD_FUNCTION("function4", &FunctionDispatcher::function4);
    ADD_FUNCTION("function5", &FunctionDispatcher::function5);
    ADD_FUNCTION("function6", &FunctionDispatcher::function6);
    ADD_FUNCTION("function7", &FunctionDispatcher::function7);
    ADD_FUNCTION("function8", &FunctionDispatcher::function8);
    ADD_FUNCTION("function9", &FunctionDispatcher::function9);
    ADD_FUNCTION("function10", &FunctionDispatcher::function10);
}

#包括“functiondispatcher.h”
#包括
#包括
#定义ADD_函数（_函数名，_函数）m_函数稳定。插入（_函数名，std:：bind（_函数，this，std:：占位符：：_1，std:：占位符：：_2））；
FunctionDispatcher:：FunctionDispatcher（QObject*父对象）
：QObject（父对象）
{
函数表（）；
}
intFunctionDispatcher:：FunctionDispatcher（QString functionName、intDataA、intDataB）
{
std:：function func=m_functionsTable.value（functionName）；
int结果=0；
试一试{
结果=func（数据a，数据b）；
}
catch（const std:：错误的函数调用&e）{
qDebug（）函数调度器（“函数1”，i，i+1）；
f->functionDispatcher（“function2”，i，i+1）；
f->functionDispatcher（“function3”，i，i+1）；
f->functionDispatcher（“function4”，i，i+1）；
f->functionDispatcher（“function5”，i，i+1）；
f->functionDispatcher（“function6”，i，i+1）；
f->functionDispatcher（“function7”，i，i+1）；
f->functionDispatcher（“function8”，i，i+1）；
f->functionDispatcher（“function9”，i，i+1）；
f->functionDispatcher（“function10”，i，i+1）；
删除f；
}
时间t2=时间（空）；
qDebug（）您可能应该在某些地方使用常量引用

int FunctionDispatcher::functionDispatcher(const QString& functionName, int dataA, int dataB)
{
    const std::function<int(int, int)>& func = m_functionsTable.value(functionName);
    int result = 0;
    try {
            result = func(dataA, dataB);
    }
    catch(const std::bad_function_call& e) {
            qDebug() << e.what();
    }

    return result;
}

int-FunctionDispatcher:：FunctionDispatcher（常量QString&functionName、int-dataA、int-dataB）
{
const std:：function&func=m_functionsTable.value（functionName）；
int结果=0；
试一试{
结果=func（数据a，数据b）；
}
catch（const std:：错误的函数调用&e）{
qDebug（）您可能应该在某些地方使用常量引用

int FunctionDispatcher::functionDispatcher(const QString& functionName, int dataA, int dataB)
{
    const std::function<int(int, int)>& func = m_functionsTable.value(functionName);
    int result = 0;
    try {
            result = func(dataA, dataB);
    }
    catch(const std::bad_function_call& e) {
            qDebug() << e.what();
    }

    return result;
}

int-FunctionDispatcher:：FunctionDispatcher（常量QString&functionName、int-dataA、int-dataB）
{
const std:：function&func=m_functionsTable.value（functionName）；
int结果=0；
试一试{
结果=func（数据a，数据b）；
}
catch（const std:：错误的函数调用&e）{
qDebug（）不要使用
std:：function
。请使用函数指针

std:：function
是任何
可调用的
目标的包装，包括函数、函子、lambda表达式等。它非常重，在您的情况下不需要它

然后确保编译时打开
-O2
（甚至
-O3
）选项。
不要使用
std:：function
。请改用函数指针

std:：function
是任何
可调用的
目标的包装，包括函数、函子、lambda表达式等。它非常重，在您的情况下不需要它

然后确保在编译时打开
-O2
（甚至
-O3
）选项。
我的最终解决方案是：

我从控制器中拆分了
Dispatcher
，只构建了一次
functionsTable
，并使用函数指针点调用函数

#include <iostream>
#include <ctime>
#include <map>

class Controller
{
public:
        int function1(int a, int b) {return a + b;}
        int function2(int a, int b) {return a + b;}
        int function3(int a, int b) {return a * b;}
        int function4(int a, int b) {return a + 50 + b/2;}
        int function5(int a, int b) {return a + b;}
        int function6(int a, int b) {return a / 2 + b;}
        int function7(int a, int b) {return a + b * 19;}
        int function8(int a, int b) {return a + b * 20;}
        int function9(int a, int b) {return a + b + 100;}
        int function10(int a, int b) {return a / b;}
};

typedef int (Controller::*function)(int a, int b);

class Dispatcher
{
public:
        Dispatcher()
        {
                m_functionsTable.insert(std::pair<std::string, function>("function1", &Controller::function1));
                m_functionsTable.insert(std::pair<std::string, function>("function2", &Controller::function2));
                m_functionsTable.insert(std::pair<std::string, function>("function3", &Controller::function3));
                m_functionsTable.insert(std::pair<std::string, function>("function4", &Controller::function4));
                m_functionsTable.insert(std::pair<std::string, function>("function5", &Controller::function5));
                m_functionsTable.insert(std::pair<std::string, function>("function6", &Controller::function6));
                m_functionsTable.insert(std::pair<std::string, function>("function7", &Controller::function7));
                m_functionsTable.insert(std::pair<std::string, function>("function8", &Controller::function8));
                m_functionsTable.insert(std::pair<std::string, function>("function9", &Controller::function9));
                m_functionsTable.insert(std::pair<std::string, function>("function10", &Controller::function10));
        }
        int FunctionDispatcher(std::string functionName, int a, int b) {
                Controller c;
                function f = m_functionsTable.find(functionName)->second;
                return (c.*(function)f)(a, b);
        }
private:
        std::map<std::string, function> m_functionsTable;
};


int main()
{

        time_t t1 = time(NULL);

        Dispatcher d;
        for (int i = 0; i < 10000000; i ++) {
                d.FunctionDispatcher("function1", i, i + 1);
                d.FunctionDispatcher("function2", i, i + 1);
                d.FunctionDispatcher("function3", i, i + 1);
                d.FunctionDispatcher("function4", i, i + 1);
                d.FunctionDispatcher("function5", i, i + 1);
                d.FunctionDispatcher("function6", i, i + 1);
                d.FunctionDispatcher("function7", i, i + 1);
                d.FunctionDispatcher("function8", i, i + 1);
                d.FunctionDispatcher("function9", i, i + 1);
                d.FunctionDispatcher("function10", i, i + 1);

        }

        time_t t2 = time(NULL);
        std::cout << t2 - t1 << std::endl;
}

#包括
#包括
#包括
类控制器
{
公众：
int function1（inta，intb）{返回a+b；}
int函数2（inta，intb）{返回a+b；}
int函数3（inta，intb）{返回a*b；}
int函数4（inta，intb）{返回a+50+b/2；}
int函数5（inta，intb）{返回a+b；}
int函数6（inta，intb）{返回a/2+b；}
int函数7（inta，intb）{返回a+b*19；}
int函数8（inta，intb）{返回a+b*20；}
int函数9（inta，intb）{返回a+b+100；}
int函数10（inta，intb）{返回a/b；}
};
typedef int（控制器：：*函数）（int a、int b）；
类调度器
{
公众：
调度员（）
{
m_functionsTable.insert（std:：pair（“function1”和Controller:：function1））；
m_functionsTable.insert（std:：pair（“function2”和Controller:：function2））；
m_functionsTable.insert（std:：pair（“function3”和Controller:：function3））；
m_functionsTable.insert（std:：pair（“function4”和Controller:：function4））；
m_functionsTable.insert（std:：pair（“function5”和Controller:：function5））；
m_functionsTable.insert（std:：pair（“function6”和Controller:：function6））；
m_functionsTable.insert（std:：pair（“function7”和Controller:：function7））；
m_functionsTable.insert（std:：pair（“function8”和Controller:：function8））；
m_functionsTable.insert（std:：pair（“function9”和Controller:：function9））；
m_functionsTable.insert（std:：pair（“function10”和Controller:：function10））；
}
int-FunctionDispatcher（std:：string-functionName，int-a，int-b）{
控制器c；