0

I am working in large application which is written in C. We allocate memory through malloc and release the memory free for different pointer. I have seen all time we have repeat check for memory failure case than release the memory. I am planning to write a utility in which the programmer will pass the pointer which they want to create and we will take care all of allocation and release of memory.

Does anyone have idea any utility function which can be use in C for allocation and release memory.

The first answer came my mind was boost library but I have received answer from my organization that they do not want to use boost library.

Improve this question
8
  • 1
    I don't understand. You have malloc, and you have free. What exactly do you want to encapsulate? Commented Dec 18, 2011 at 12:07
  • boost is mostly a C++ library, not C. It's not clear what you are after, unless you want to build a sort of garbage collector - but that's a huge undertaking. Commented Dec 18, 2011 at 12:08
  • Boost is available for C programming? Commented Dec 18, 2011 at 12:10
  • 1
    Do you want to abstract away all the error checking? If so then you are out of luck. The language doesn't support what you need to do this, i.e. exceptions. Commented Dec 18, 2011 at 12:10
  • 1
    @user765443: Please edit your question to include this new example. Commented Dec 18, 2011 at 12:23

4 Answers 4

Reset to default
2

How about Boehm Garbage Collector?

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

2

If you are just looking for a unified way (without code duplication) to check if allocation was successful or not, please see the last segment of this post.

First of all boost is mainly a library for C++, therefor all of boost can't be used in C.

Writing your own Garbage Collector is not easy, especially in a language without true OOP (such as C). There are many implementations of garbage collectors available online, so instead of reinventing the wheel you could check out some of them.

If you are not going to use any of them, well.. at least they will provide you with some information regarding how the problem can be solved.

Depending on the project size you might be better of using valgrind looking for leaking data and then manage the memory allocation/release by yourself.

C has been around for many years, and a lot of developers have managed without a automatic garbage collector. Why shouldn't you be able to do the same?

Simple error checking on allocation (and abort on error)

#include <stdio.h> #include <stdlib.h> void* safe_alloc_check (void *p, size_t size) { if (p == NULL) { printf ("ERROR: Unable to allocate memory for %lu bytes!", size); exit (-1); } return p; } #define s_malloc(N) safe_alloc_check(malloc(N),N) #define s_calloc(C,N) safe_alloc_check(calloc(C,N),N) #define s_realloc(P,N) safe_alloc_check(realloc(P,N),N) ... int *p = s_malloc (sizeof (int));
Improve this answer

3 Comments

"Boost can't be used for C" -> not entirely true. There are some Boost headers that are designed to be used by either C or C++.
Yes I am looking for similar thing in more generalized purpose which can be use in strcuture also. You have mentioned this code specific to my example. But I am planning to write a function So other programmer can call utility function like wrapper kind of thing(appropriate word) because #define will not be much useful as it will be replacing code internally (Saving . But Thanks a lot for giving some guidence.
@user765443 macros can be used efficiently, and it will also shave of one additional function call which in the long run could shave of some time. But you should have all the information needed to write your own functions with the desired functionality, good luck!
0

Wrap malloc in a function (often called xmalloc) which aborts when malloc fails to return a new memory chunk (by returning NULL).

If you are on a Unix system, using valgrind to catch memory leaks is helpful.

If you want a garbage collector for C, consider using Boehm's garbage collector

Improve this answer

1 Comment

Sorry Boost is mainly for c++. Adding some example for better clarification . Ex. int p =(int)malloc(sizeof(int); and int *s=(int *)malloc(sizeof(int)); if (p==NULL) return no_memory if(s==NULL) return no_memory so we create couple of pointer like this and do memory check for every pointer. So can we write any utility like MALLOC(P) or MALLOC(S) and internally we will take care all this check. so we can avoid some piece of duplicate code . I hope I have clarify myself.
0

I'm not sure what you're after. An often used technique for handling memory allocation and deallocation in C is implementing a memory trace data structure which holds a number of pointers to memory that has been allocated using your own implementation of malloc, calloc, realloc, e.g. mymalloc, mycalloc, myrealloc (calling the original functions themselves) and then using a new function free_memtrace to free all the memory that has been recorded in a trace in one function call.

So e.g. you could do

MEMTRACE mt; // Possibly a module-scoped global variable begin_memtrace( &mt ); ptr1 = mymalloc( size ); ptr2 = mycalloc( n, sizeof(type) ); end_memtrace( &mt );

and then at some point in your program

free_memtrace( &mt );

to clear the memory recorded in mt.

The begin_memtrace, end_memtrace functions are needed so that your allocation functions "know" where to record the pointers. That information could be stored locally in the module where you implement mymalloc, mycalloc, myfree, free_memtrace ....

Improve this answer

1 Comment

Can you have some info how can I implement in my system. I did not find any example in existing code base use this technique.