v0.40: Create exercises. Challenge the community.

mem_resize

Your mission

Reimplement realloc's grow/shrink pattern with an explicit old size: move a heap block to a buffer of a new size while keeping its leading bytes.

See it in action

p = malloc(4); /* 'A','B','C','D' */ q = mem_resize(p, 4, 8);

Expected result

first 4 bytes of q: ABCD

Your checklist

For your own tracking. Tests grade your code.

Allocate new_size bytes with malloc. If the allocation fails, return NULL.
If ptr is NULL, there is nothing to preserve, just behave like malloc(new_size).
Otherwise copy the first min(old_size, new_size) bytes from ptr into the new block, byte by byte.
Free the old block with free(ptr), then return the new one.
Why the explicit old_size? The real two-argument realloc can't be written in user code: there is no portable way to ask the allocator how big an existing block was, and <stdlib.h> already declares realloc. This signature hands you that missing size so you can copy exactly the right amount.
Bytes past min(old_size, new_size) in a grown block are uninitialized, that space belongs to the caller to fill.

More examples

p = malloc(8); /* 'A'..'H' */ q = mem_resize(p, 8, 4);

Expected result

first 4 bytes of q: ABCD

q = mem_resize(NULL, 0, 6); /* like malloc(6) */

Expected result

q is a fresh 6-byte block

Constraints

Expected files

mem-resize.c

Allowed functions

mallocfree

Allowed headers

<stdlib.h>declares malloc and free

<stddef.h>defines size_t

libc

Standard C library

Implements the contract of a function from the standard C library.

mem_resize

Dynamic memory

Your mission

Reimplement realloc's grow/shrink pattern with an explicit old size: move a heap block to a buffer of a new size while keeping its leading bytes.

See it in action

p = malloc(4); /* 'A','B','C','D' */ q = mem_resize(p, 4, 8);

Expected result

first 4 bytes of q: ABCD

Your checklist

For your own tracking. Tests grade your code.

Allocate new_size bytes with malloc. If the allocation fails, return NULL.
If ptr is NULL, there is nothing to preserve, just behave like malloc(new_size).
Otherwise copy the first min(old_size, new_size) bytes from ptr into the new block, byte by byte.
Free the old block with free(ptr), then return the new one.
Why the explicit old_size? The real two-argument realloc can't be written in user code: there is no portable way to ask the allocator how big an existing block was, and <stdlib.h> already declares realloc. This signature hands you that missing size so you can copy exactly the right amount.
Bytes past min(old_size, new_size) in a grown block are uninitialized, that space belongs to the caller to fill.

More examples

p = malloc(8); /* 'A'..'H' */ q = mem_resize(p, 8, 4);

Expected result

first 4 bytes of q: ABCD

q = mem_resize(NULL, 0, 6); /* like malloc(6) */

Expected result

q is a fresh 6-byte block

Constraints

Expected files

mem-resize.c

Allowed functions

mallocfree

Allowed headers

<stdlib.h>declares malloc and free

<stddef.h>defines size_t

libc

Standard C library

Implements the contract of a function from the standard C library.

Tests

Run the tests to grade your code

Build your code, then check each test here. Open a result to inspect its output.

Build

01Grow keeps the leading bytesWaiting

02Shrink keeps min(old, new) bytesWaiting

03NULL ptr behaves like mallocWaiting

04NULL ptr ignores old_sizeWaiting

05Grow preserves a short string and its NULWaiting

06Shrink drops the tail past new_sizeWaiting

07Same-size resize preserves every byteWaiting

08Grown tail is the caller's to fillWaiting

mem_resize

Your mission

Reimplement realloc's grow/shrink pattern with an explicit old size: move a heap block to a buffer of a new size while keeping its leading bytes.

See it in action

p = malloc(4); /* 'A','B','C','D' */ q = mem_resize(p, 4, 8);

Expected result

first 4 bytes of q: ABCD

Your checklist

For your own tracking. Tests grade your code.

Allocate new_size bytes with malloc. If the allocation fails, return NULL.
If ptr is NULL, there is nothing to preserve, just behave like malloc(new_size).
Otherwise copy the first min(old_size, new_size) bytes from ptr into the new block, byte by byte.
Free the old block with free(ptr), then return the new one.
Why the explicit old_size? The real two-argument realloc can't be written in user code: there is no portable way to ask the allocator how big an existing block was, and <stdlib.h> already declares realloc. This signature hands you that missing size so you can copy exactly the right amount.
Bytes past min(old_size, new_size) in a grown block are uninitialized, that space belongs to the caller to fill.

More examples

p = malloc(8); /* 'A'..'H' */ q = mem_resize(p, 8, 4);

Expected result

first 4 bytes of q: ABCD

q = mem_resize(NULL, 0, 6); /* like malloc(6) */

Expected result

q is a fresh 6-byte block

Constraints

Expected files

mem-resize.c

Allowed functions

mallocfree

Allowed headers

<stdlib.h>declares malloc and free

<stddef.h>defines size_t

libc

Standard C library

Implements the contract of a function from the standard C library.

v0.40: Create exercises. Challenge the community.

Meet Studio →

mem_resize

Dynamic memory

Your mission

Reimplement realloc's grow/shrink pattern with an explicit old size: move a heap block to a buffer of a new size while keeping its leading bytes.

See it in action

p = malloc(4); /* 'A','B','C','D' */ q = mem_resize(p, 4, 8);

Expected result

first 4 bytes of q: ABCD

Your checklist

For your own tracking. Tests grade your code.

Allocate new_size bytes with malloc. If the allocation fails, return NULL.
If ptr is NULL, there is nothing to preserve, just behave like malloc(new_size).
Otherwise copy the first min(old_size, new_size) bytes from ptr into the new block, byte by byte.
Free the old block with free(ptr), then return the new one.
Why the explicit old_size? The real two-argument realloc can't be written in user code: there is no portable way to ask the allocator how big an existing block was, and <stdlib.h> already declares realloc. This signature hands you that missing size so you can copy exactly the right amount.
Bytes past min(old_size, new_size) in a grown block are uninitialized, that space belongs to the caller to fill.

More examples

p = malloc(8); /* 'A'..'H' */ q = mem_resize(p, 8, 4);

Expected result

first 4 bytes of q: ABCD

q = mem_resize(NULL, 0, 6); /* like malloc(6) */

Expected result

q is a fresh 6-byte block

Constraints

Expected files

mem-resize.c

Allowed functions

mallocfree

Allowed headers

<stdlib.h>declares malloc and free

<stddef.h>defines size_t

libc

Standard C library

Implements the contract of a function from the standard C library.

Tests

Run the tests to grade your code

Build your code, then check each test here. Open a result to inspect its output.

Build

01Grow keeps the leading bytesWaiting

02Shrink keeps min(old, new) bytesWaiting

03NULL ptr behaves like mallocWaiting

04NULL ptr ignores old_sizeWaiting

05Grow preserves a short string and its NULWaiting

06Shrink drops the tail past new_sizeWaiting

07Same-size resize preserves every byteWaiting

08Grown tail is the caller's to fillWaiting