Question

假设一个类用于从某个位置读取数据并以不同的格式（而不是线程安全）提供它。对于它读取的每个项目，它都是这样的：

TargetDataStruct HostToTargetConverter::Next()
{
  HostDataStruct source;
  sourceData->GetItem(m_index++, &source);

  TargetDataStruct target;
  target.seize = source.day;
  target.have = source.fun;
  return target;
}

在编译器的速度或可优化性方面，将HostDataStruct source和TargetDataStruct target声明为成员变量会有什么不同吗？我的想法是每次调用都不需要在堆栈上推送这两个结构，并且不需要每次都进行初始化。

Answer 1

在您的代码中HostDataStruct＆amp; TargetDataStruct位于堆栈中，因此对读/写的访问速度最快。

优化删除所有不必要的操作

现在，如果将源和目标作为成员，那么唯一可以使代码更快的是，如果对象构造函数需要多次（通常在构造函数中调用“new”），并且经常调用代码。 / p>

为了便于阅读，您可以创建一个这样的转换构造函数：

TargetDataStruct(const HostDataStruct& value);

所以你的代码将是

TargetDataStruct HostToTargetConverter::Next()
{
    HostDataStruct source;
    sourceData->GetItem(m_index++, &source);
    return TargetDataStruct(source);
}

但是如果你的sourceData容器/对象保持数据存活，你也可以避免HostDataStruct分配，使你的sourceData-＆gt; GetItem（）返回一个const HostDataStruct＆amp ;;

const HostDataStruct& GetItem(const int p_id);

您的代码将是这样的：

TargetDataStruct HostToTargetConverter::Next()
{
    return TargetDataStruct(sourceData->GetItem(m_index++, &source));
}

最后一个解决方案应该是最快的，避免无用的副本和对象构建。

如果您仍需要性能，即：如果您经常调用代码，请执行以下操作：在第一次调用时，在缓存中构建TargetDataStruct，然后始终返回对缓存数据的引用。

Answer 2

一般来说，不可能给出比“依赖”更好的答案。

将HostDataStruct和TargetDataStruct纳入成员所带来的差异包括：

他们的每次访问都会取消引用指针。在一个成员中访问source和target的包含类的功能分别评估this->source和this->target（即解除引用this）。
如果包含对象仅构造一次（例如，未创建并且反复销毁）然后对其成员也是如此。那表示构造的开销只发生一次（对于包含对象的每个实例），与每次调用函数时构造它们相比。
在您的代码中，将在您的函数中重新分配对象（即其值已更改）。每次调用函数时都会产生这种开销（以及抵消事件构造函数只被调用一次的成本）。

事实上，这些事情的成本确实有所不同。小物体的构造和破坏成本低廉，而较大的物体构造和破坏成本更高。复杂的构造函数（或析构函数）最好只构造一次对象（即使对象很小，构造函数也可能访问其他资源）。访问本地构造对象的成员是编译器可以有效实现的，而解除引用指针涉及更多操作，因此编译器可能无法特别有效地实现。

要确定哪个选项提供更好的运行时间速度，您需要进行测试 - 例如使用分析器。您获得的结果可能特定于您的编译器，主机配置等等。

使用成员函数变量时，优化/速度有什么不同吗？

2 个答案: