变量而不是类调用-variablesasopposedtoclasscalls

9  

Whoever told you this probably thought that the second version was likely to be faster.

谁告诉你这可能认为第二个版本可能会更快。

I think this is bad advice, for two reasons:

我认为这是一个糟糕的建议,原因有两个:

1. It may or may not actually be faster. This depends on the compiler, on what exactly the code is doing etc.

实际上可能会或可能不会更快。这取决于编译器,代码究竟在做什么等等。

2. Even if it is faster, this screams premature optimization. One should micro-optimize only after profiling the code and establishing which part of the code is the overall bottleneck.

即使它更快,这也会过早地优化。只有在分析代码并确定代码的哪一部分是整体瓶颈之后,才应进行微优化。

8  

The concept is intuitive, but wrong. The concept is that accessing members takes more calculations than local variables, so by converting members to variables, you save performance.

这个概念很直观,但错了。概念是访问成员比局部变量需要更多的计算,因此通过将成员转换为变量,可以节省性能。

But this is wrong. Your compiler will optimize this in ways you could never imagine. Don't attempt to be smarter than the compiler.

但这是错误的。您的编译器将以您无法想象的方式优化它。不要试图比编译器更聪明。

6  

This could actively be dangerous. If s.centre or s.radius change during the execution of this function (say due to a function you call or another thread), you will end up with two inconsistent, old values in your local variables -- causing bugs. Even if you're doing this safely, why take the chances of introducing bugs when you can just refer back to the canonical variables themselves?

这可能会非常危险。如果s.centre或s.radius在执行此函数期间发生更改(比如由于您调用的函数或其他线程),您最终会在本地变量中出现两个不一致的旧值 - 导致错误。即使您正在安全地执行此操作,为什么在您可以回溯到规范变量本身时,还有机会引入错误?

5  

You were lied to. Moreover, you should not be worrying about such minutiae unless you have profiled your code and found this to be a main source of inefficiency in your code. Don't try to outsmart your compiler's optimizer. It is better at optimizing your code than you are.

你被骗了。此外,除非您对代码进行了分析并发现这是代码中效率低下的主要原因,否则您不应该担心这种细节。不要试图超越编译器的优化器。优化代码比使用它更好。

2  

Here is a general outlook of your code:

以下是您的代码的一般展望:

void function(Sphere s)
{
    Vector3 centre = s.centre; float radius = s.radius;
    //an equal amount of calls to centre and radius
}

First off, you'd gain much more efficiency by passing Sphere as a const reference. This way, a new copy isn't created, which is probably more expensive than member access. So the way to go is:

首先,通过将Sphere作为const引用传递,您将获得更高的效率。这样,不会创建新副本,这可能比成员访问更昂贵。所以要走的路是:

void function(const Sphere& s)
{
    Vector3 centre = s.centre; float radius = s.radius;
    //an equal amount of calls to centre and radius
}

Secondly, you shouldn't access members of classes directly. It may be easy now, but in a large project it's really hard to debug. You should use inline getters and setters. That way, the generated code is the same, but you have a single entry point.

其次,您不应该直接访问类的成员。现在可能很容易,但在大型项目中,调试真的很难。您应该使用内联getter和setter。这样,生成的代码是相同的,但您只有一个入口点。

Thirdly, this version isn't thread safe. What if a different thread changes s? s.center and s.radius would change, but you'd still be operating on the old values.

第三,这个版本不是线程安全的。如果另一个线程改变了怎么办? s.center和s.radius会改变,但你仍然会使用旧值。

Lastly, compilers do a better job at optimizing than you can, so it's better to leave this one up to the compiler.

最后,编译器在优化方面做得比你做得更好,所以最好把这个放到编译器上。

0  

Whoever told you that is wrong. You can improve performance by using inline functions. Also in your example use

谁告诉你这是错的。您可以使用内联函数来提高性能。另外在你的例子中使用

void function(Sphere &s) 

Saves using the copy constructor.

使用复制构造函数保存。