Allocating and copying memory in one go...

[John E]

This code will copy the contents of src to dest

void SomeFunc(void *src, size_t size)
{
void* dest;

	if (memcpy (dest = malloc (size), src, size))
	{
		// Do something
	}
}

although it involves separate calls to memcpy() and malloc(). I just wondered if there's any single function which combines both jobs - e.g.

void SomeFunc(void *src, size_t size)
{
void* dest;

	if (dest = some_copying_function (src, size))
	{
		// Do something
	}
}

[2kaud]

Not that I'm aware of as part of the standard library. It's easy to write your own though.

Note that in the code posted in post #1 there is an issue. If malloc() fails it returns NULL so memcpy() will try to copy data to location 0 which will cause an exception. The result of malloc() should be tested before being used.

Consider

void* copymem(const void* src, size_t sz)
{
	void* newmem = malloc(sz);
	if (newmem == NULL)
		return NULL;

	return memcpy(newmem, src, sz);
}

void SomeFunc(const void *src, size_t size)
{
void* dest = copymem(src, size);

	if (dest)
	{
		// Do something
                free(dest)
	}
}

Note that the caller of copymem() is responsible for freeing memory using free().

Are you writing c rather than c++?

[John E]

Hi 2kaud - ultimately it'll be C++ but I was just curious. It occurred to me that a standard library function to do both operations would have been quite useful. I just wondered if such a function existed but I'd managed to miss it somehow !

[2kaud]

ultimately it'll be C++

Then I would write it as a RAII class.

[Richard.J]

John, did you consider realloc?

[John E]

Hi Richard - as I understand it, realloc() needs to be given the address of a previously allocated memory block - so it's essentially still a 2-stage process (or can you pass NULL for that initial memblock parameter ?)

[2kaud]

If you pass NULL for the memblock parameter it behaves the same as malloc(). It still doesn't provide the required copy facility. If realloc() can provide the extra required memory without moving (ie contiguous with the currently allocated memory), it will do so. Otherwise realloc() allocates a new block of the required size, copies from the old to the new, frees the old memory and returns a pointer to the newly allocated memory. You still need to copy from src to the newly allocated memory.