堆上的分配是否会影响访问性能？

Question

As known:

ptr = malloc(size);

or in C++

ptr = new Klass();

will allocate size bytes on the heap. It is less efficient than on the stack.

But after the allocation, when we access it:

foo(*ptr);

or

(*ptr)++;

Does it have the same performance as data on the stack, or still slower?

Answer 1

The only way to definitively answer this question is to code up both versions and measure their performance under multiple scenarios (different allocation sizes, different optimiziation settings, etc). This sort of thing depends heavily on a lot of different factors, such as optimization settings, how the operating system manages memory, the size of the block being allocated, locality of accesses, etc. Never blindly assume that one method is more "efficient" than another in all circumstances.

Even then, the results will only be applicable for your particular system.

Answer 2

It really depends on what you are comparing and how.

If you mean is

ptr = malloc(10 * sizeof(int)); 

slower than:

int arr[10]
ptr = arr; 

and then using ptr to access the integers it points at?

Then no.

If you are referring to using arr[0] instead of *ptr in the second case, possibly, as the compiler has to read the value in ptr to find the address of the actual variable. In many cases, however, it will "know" the value inside ptr , so won't need to read the pointer in itself.

If we are comparing foo(ptr) and foo(arr) it won't make any difference at all.

[There may be some penalty in actually allocating on the heap in that the memory has to be "committed" on the first use. But that is at most once for each 4KB, and we can probably ignore that in most cases].

Answer 3

Efficiency considerations are important when comparing an algorithm that runs in O(n^2) time versus O(nlogn), etc.

Comparing memory storage accesses, both algorithms are O(n) or O(k) and usually is is NOT possible to measure any difference.

However, if you are writing some code for the kernel that is frequently invoked than a small difference might become measurable.

In the context of this question, the real answer is that it really doesn't matter, use whichever storage makes your program easy to read and maintain. Because, in the long run the cost of paying humans to read your code is more than the cost of a running a cpu for a few more/or less instructions.

Answer 4

Stack is much faster than Heap since it involves as simple as moving the stack pointer. stack is of fixed size. in contrast to Heap, user need to manually allocate and de-allocate the memory.