C what does free do

Create account Log in. Namespaces Page Discussion. Views View Edit History. Take a step-up from those "Hello World" programs. Learn to implement data structures like Heap, Stacks, Linked List and many more! Check out our Data Structures in C course to start learning today. As it can be seen that the length size of the array above made is 9. But what if there is a requirement to change this length size. For Example, If there is a situation where only 5 elements are needed to be entered in this array.

In this case, the remaining 4 indices are just wasting memory in this array. So there is a requirement to lessen the length size of the array from 9 to 5.

Take another situation. In this, there is an array of 9 elements with all 9 indices filled. But there is a need to enter 3 more elements in this array. In this case, 3 indices more are required. So the length size of the array needs to be changed from 9 to Connect and share knowledge within a single location that is structured and easy to search. But was it better just to set a flag in my list as 'is free' rather than doing a memset in order to make it faster?

Which can cause memory leaks. Usually free 3 does not do anything to the memory itself. If security or privacy is a concern, you should clear memory before freeing. If you want to implement malloc, you need to have some database of free memory blocks. When memory is freed you should join it with adjoint free memory, if there is any. If a complete page ends up unused, you should tell the kernel, that you don't need it anymore depending on how you got that memory in the first place.

Stack Overflow for Teams — Collaborate and share knowledge with a private group. Create a free Team What is Teams? Collectives on Stack Overflow. Learn more. C - What does free do to the memory? Ask Question. Asked 6 years, 9 months ago. Active 12 months ago. Viewed 10k times. I recoded malloc free and realloc. Heap corruption is a likely result. Or worse. Your program will probably die. Sometimes programmers think that the [] in the delete[] p only exists so the compiler will call the appropriate destructors for all elements in the array.

Because of this reasoning, they assume that an array of some built-in type such as char or int can be delete d without the []. But the above code is wrong, and it can cause a disaster at runtime. Long answer: The run-time system stores the number of objects, n , somewhere where it can be retrieved if you only know the pointer, p. There are two popular techniques that do this.

Both these techniques are in use by commercial-grade compilers, both have tradeoffs, and neither is perfect. These techniques are:. There are many ways to do this, depending on how flexible you want the array sizing to be.

On one extreme, if you know all the dimensions at compile-time, you can allocate multidimensional arrays statically as in C :. Finally at the other extreme, you may not even be guaranteed that the matrix is rectangular.

In the following function, ncols[i] is the number of columns in row number i , where i varies between 0 and nrows-1 inclusive. Note the funny use of matrix[i-1] in the deletion process.

This prevents wrap-around of the unsigned value when i goes one step below zero. Finally, note that pointers and arrays are evil. It is normally much better to encapsulate your pointers in a class that has a safe and simple interface. The following FAQ shows how to do this. The reason the code in the previous FAQ was so tricky and error prone was that it used pointers, and we know that pointers and arrays are evil.

The solution is to encapsulate your pointers in a class that has a safe and simple interface. For example, we can define a Matrix class that handles a rectangular matrix so our user code will be vastly simplified when compared to the the rectangular matrix code from the previous FAQ :. The main thing to notice is the lack of clean-up code.

Note that the above Matrix class accomplishes two things: it moves some tricky memory management code from the user code e. The latter point is important. For example, assuming Matrix is even mildly reusable, moving complexity from the users [plural] of Matrix into Matrix itself [singular] is equivalent to moving complexity from the many to the few. Anyone who has seen Star Trek 2 knows that the good of the many outweighs the good of the few… or the one.

For example, the following uses a Matrix of std::string where std::string is the standard string class :. You can thus get an entire family of classes from a template. Use the standard vector template, and make a vector of vector.

Note how much simpler this is than the previous : there is no explicit new in the constructor, and there is no need for any of The Big Three destructor, copy constructor or assignment operator. Simply put, your code is a lot less likely to have memory leaks if you use std::vector than if you use explicit new T[n] and delete[] p. Yes, in the sense that the standard library has a std::vector template that provides this behavior.

Yes, in the sense that even built-in array types can specify the first index bounds at run-time. Arrays are evil. Use some object of some class if you can. Use arrays only when you have to. Use the Named Constructor Idiom. In this case the create methods allocate the objects via new. Since the constructors themselves are not public , there is no other way to create objects of the class.

Make sure your constructors are in the protected section if you expect Fred to have derived classes. Note also that you can make another class Wilma a friend of Fred if you want to allow a Wilma to have a member object of class Fred , but of course this is a softening of the original goal, namely to force Fred objects to be allocated via new. One of the implicit constraints on FredPtr is that it must only point to Fred objects which have been allocated via new. Thus no one could accidentally subvert the reference counting mechanism.