CODEWITHSUNDEEP
c++refactoring
JavaRunner
JavaRunner

Reputation: 2545

What's better to use and why?

class MyClass {
    private:
        unsigned int currentTimeMS;
    public:
        void update() {
            currentTimeMS = getTimeMS();
            // ...
        }
};

class MyClass {
    public:
        void update() {
            unsigned int currentTimeMS = getTimeMS();
            // ...
        }
};

update() calls in main game loop so in the second case we get a lot of allocation operations (unsigned int currentTimeMS). In the first case we get only one allocate and use that allocated variable before. Which of this code better to use and why?

Upvotes: 0

Views: 172

Answers (5)

Frank Puffer
Frank Puffer

Reputation: 8215

I recommend the second variant because it is stateless and the scope of the variable is smaller. Use the first one only if you really experience a performance issue, which I consider unlikely.

If you do not modify the variable value later, you should also consider to make it const in order to express this intent in your code and to give the compiler additional optimization options.

Upvotes: 8

David Hammen
David Hammen

Reputation: 33126

Which of this code better to use and why?

First and foremost, the cited code is at best a tiny micro-optimization. Don't worry about such things unless you have to.

In fact, this is most likely a disoptimization. Sometimes automatic variables are allocated on the stack. Stack allocation is extremely fast (and even free sometimes). There is no need to worry. Other times, the compiler may place a small automatic variable such the unsigned int used here in a register. There's no allocation whatsoever.

Compare that to making the variable a data member of the class, and solely for the purpose of avoiding that allocation. Accessing that variable involves going through the this pointer. Pointer dereference has a cost, potentially well beyond that of adding an offset to a pointer. The dereference might result in a cache miss. Even worse, this dereferencing may well be performed every time the variable is referenced.


That said, sometimes it is better to create data members solely for the purpose of avoiding automatic variables in various member functions. Large arrays declared as local automatic variables might well result in stack overflow. Note, however, that making double big_array[2000][2000] a data member of MyClass will most likely make it impossible to have a variable of type MyClass be declared as a local automatic variable in some function.

The standard solution to the problems created by placing large arrays on the stack is to instead allocate them on the heap. This leads to another place where creating a data member to avoid a local variable can be beneficial. While stack allocation is extremely fast, heap allocation (e.g., new) is quite slow. A member function that is called repeatedly may benefit by making the automatic variable std::unique_ptr<double> big_array = std::make_unique<double>(2000*2000) a data member of MyClass.

Note that neither of the above applies to the sample code in the question. Note also that the last concern (making an heap-allocated variable a data member so as to avoid repeated allocations and deallocations) means that the code has to go through the this pointer to access that memory. In tight code, I've sometimes been forced to create a local automatic pointer variable such as double* local_pointer = this->some_pointer_member to avoid repeated traversals through this.

Upvotes: 0

Vucko
Vucko

Reputation: 7479

It depends upon your needs. If currentTimeMS is needed only temporarily in the update(), then surely declare it there. (in your case, #option2)

But if it's value is needed for the instance of the class (i.e. being used in some other method), then you should declare it as a field (in your case, #option1).

Upvotes: 1

Tim Rutter
Tim Rutter

Reputation: 4679

The first case is defining a member variable the second a local variable. Basic class stuff. A private member variable is available to any function (method) in that class. a local variable is only available in the function in which it is declared.

Upvotes: 0

Pedro G. Dias
Pedro G. Dias

Reputation: 3222

In the first example, you are saving the state of this class object. In the second one, you're not, so the currentTime will be lost the instant update() is called.

It is really up to you to decide which one you need.

Upvotes: 0

Related Questions