Dynamic memory fragmentation C

Question

1.00/5 (1 vote)

See more:

Despite the performances issues, I currently don't use the arithmetic of pointers in the block of memory allocated dynamically such:

int* foo =malloc(sizeof(int)*100);
     *(foo+1)=100; //I do not use this form
     foo[1]=100;//but this

this because I am afraid of the possible fragmentation of the memory. That randomly could crush and raise an infamous SIGSEV.
But are my fears justified? Can I use the arithmetic of pointers with allocated memory?

What I have tried:

I cannot try, since the problem comes from the way the program allocated the memory

Posted 28-Jun-16 21:23pm

jurhas

Updated 28-Jun-16 21:42pm

Add a Solution

3 solutions

Solution 1

No, your fears are not justified. It does not matter whether you use *(foo+1) or foo[1], they both result in exactly the same object code.

Posted 28-Jun-16 21:37pm

Richard MacCutchan

Solution 2

"But are my fears justified?"
No. Not even slightly!
Memory fragmentation is not caused by how you access the memory, it's caused by allocating and freeing chunks of memory in such a way that lots of smaller, useless holes appear that can't be reused as a "bigger chunk" because they aren't contiguous.
There is a good description here: Developer Library » Memory Fragmentation, your worst nightmare[^] - and it has pictures, without which it's really, really difficult to explain what is happening!

But accessing your pointers via pointer arithmetic doesn't have anything to do with fragmentation, as it doesn't cause any new allocation of memory or return any memory to the pool - those have to be explicit in C via malloc and free

Posted 28-Jun-16 21:40pm

OriginalGriff

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Jochen Arndt · Accepted Answer · 2016-06-28T21:42:00

There is no difference between the methods. The compiler will usually generate the same assembly code for both methods.

This is also not related to memory fragmentation. Heap memory fragmentation occurs when allocating and freeing memory frequently which may result in unused freed blocks.

Getting a segmentation fault is the result of accessing memory out of bounds. For your example this happens when using a negative index or an index greater or equal to 100 or - even worse - using casted pointers to a differnt type. Because C has not implemented bound checking, you must do it by writing corresponding code to ensure that it can not happen.

If you got segmentation faults you have to check and debug your code to find the source.