What I mean is, imagine a very large allocation say 4MB. Maybe that's not
available in one chunk, however 4 seperate 1MB allocations could succeed.
That sort of thing.
Here's code that shows how to do something like that:
#define BLOCK_SIZE 0x40000000
#define NUM_BLOCKS 4
#define BUFFER_SIZE (NUM_BLOCKS * BLOCK_SIZE)
// Note: on many systems the calculation of BUFFERSIZE will overflow
int func(void)
{
void *blocks[NUM_BLOCKS] = {0};
int numb;
blocks[0] = malloc(BUFFER_SIZE);
// Even if the calculation doesn't overflow, the conversion to
// size_t may cause unsigned wrap-around. I'll leave it as an
// exercise for the reader to figure out how to deal with those
// possibilities.
if(blocks[0])
{
for(numb=0; numb<NUM_BLOCKS-1; numb++)
blocks[numb+1] = blocks[numb] + BLOCK_SIZE;
}
else
{
for(numb=0; numb<NUM_BLOCKS && blocks[numb]=malloc(BLOCK_SIZE);
numb++);
}
if(numb == NUM_BLOCKS)
{
// code that works with blocks[];
// the key thing is that this code doesn't care whether or not
// the block of memory pointed at by block[1] immediately
// follows the block pointed at by block[2].
}
else
{
// error handling for insufficient memory
}
while(numb>0)
free(blocks[--numb]);
}
However, if you can write your code to work with 4 smaller blocks, it's
probably best to always allocate 4 blocks, rather than one large one.
By stack I mean essentially a local array, i.e.
func()
{
char buf[1000]; /* <--- example */
/* buf can never be Null */
}
Note, that in this case, Null can never be returned for the array.
OK, that's a different approach. Here's some code that shows how
something like that could be done:
int called(void*); // This function does the actual work.
int caller(void)
{
void *p = malloc(BUFFER_SIZE);
if(p)
return called(p);
else
{
char buf[BUFFER_SIZE];
return called(buf);
}
}
Note: if p is non-null, it's guaranteed to be correctly aligned for any
object type. No such guarantee applies to buf. If called() makes use of
the pointer in any way that requires a special alignment, you need to do
something to make sure that 'buf' is suitably aligned. In C99, you
should declare the parameter of called() as being a pointer to an object
with suitable alignment requirements, and declare buf to be an array of
that same object type. C 2011 adds some new alignment-oriented features
that allow for more exotic ways of achieving that same purpose, but this
is still the most appropriate method to use.
On many systems, the memory pointed at by 'p' comes out of the heap,
while 'buf' resides on the stack, but the C standard doesn't use those
terms, and does not require that such things even exist. The stack and
the heap could be two separate memory pools, or they could be different
ends of the same block of memory; more complicated alternatives exist as
well. If they are from a single block of memory, not having enough heap
for malloc() to succeed could correspond to not having enough stack for
the allocation of buf to occur. If that's the case, the behavior of that
program is undefined, and there's nothing you can do to prevent that,
anticipate that, or deal with it.
