c++ - 避免堆分配的宏？在这种情况下很糟糕吗？

Question

这是我的第一个问题，这是一个菜鸟问题:)。

我正面临 C++ 和 Qt 4.6 的问题，因为我想通过 QMetaMethod::invoke() 方法分解我的一些代码，这些代码正在调用 QObject 的一些公共(public)槽。

我面临的问题是 Q_ARG 宏定义如下:

#define Q_ARG(type, data) QArgument<type >(#type, data)

也就是说我应该在编译时知道类型。但另一方面，我得到了我对该方法的论点，这些论点以 QVariants 的形式出现。我可以通过 ->type() 访问器获取它们的类型，它返回 QVariant::Type 类型的枚举值，但自然不是编译时类型。

因此，为了简单地生成调用的参数，我制作了以下宏:

#define PASS_SUPPORTED_TYPE(parameterToFill, requiredType, param, supported) {      \
                                            \
        switch (requiredType) {                         \
            case QVariant::String:                      \
                parameterToFill = Q_ARG(QString,            \
                        param.value<QString>());        \
            break;                              \
                                            \
            case QVariant::Int:                         \
                parameterToFill = Q_ARG(int, param.value<int>());   \
            break;                              \
                                                        \
            case QVariant::Double:                      \
                parameterToFill = Q_ARG(double, param.value<double>()); \
            break;                              \
                                                        \
            case QVariant::Char:                        \
                parameterToFill = Q_ARG(char, param.value<char>());     \
            break;                              \
                                                        \
            case QVariant::Bool:                        \
                parameterToFill = Q_ARG(bool, param.value<bool>());     \
            break;                              \
                                                        \
            case QVariant::Url:                         \
                parameterToFill = Q_ARG(QUrl, param.value<QUrl>());     \
            break;                              \
                                                        \
            default:                            \
                supported = false;                  \
                                            \
        }                                   \
                                            \
        supported = true;                           \
}

在可以返回 true 或 false 而不是设置“supported”标志的方法中也可以这样做，但这会迫使我在这种情况下进行堆分配，因为“param.value()”调用返回QVariant 值的拷贝，我应该通过新的或通过 memset 将其存储在堆中。

这就是我的问题，我不想在这个方法中进行堆分配，因为这会被调用数千次(这是一个请求处理模块)。

for (int k = 0; k < methodParams.size(); ++k) {
    QVariant::Type paramType = QVariant::nameToType(methodParams[k].toAscii());

    [...]

    bool supportedType = false;

    PASS_SUPPORTED_TYPE(
            paramsToPass[k], 
            paramType, 
            params[k],
            supportedType);
   [...]
}

metaMethod.invoke(objectToCall, paramsToPass[0], paramsToPass[1], paramsToPass[2] [...]);

这让我不满意，因为它不是类型安全的。所以我要问自己的问题是，我怎样才能触发这个宏，并用一个可以进行堆栈分配而不是堆分配的方法替换它？

我提前感谢大家的帮助和兴趣。

Answer 1

And that is my problem, I don't want to do heap allocation in this method, because this will get called thousands of time (this is a request handling module).

不要事后猜测性能问题。是的，堆栈分配更快，是的，在不需要时应该避免复制。然而，这对我来说似乎是过早的优化。

看来您正在构建一个非常复杂的代码架构以节省几个 CPU 周期。最后，您将无法可靠地判断调用了什么以及调用了多少次。而且您将拥有无法维护的代码。

我的建议是:关注代码的正确性和简单性，如果您确实在某个时候遇到性能问题，请剖析您的代码以查看问题所在。