mem_resize

Dynamic memory32

Objective

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.

Steps

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.

examples

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

first 4 bytes of q: ABCD

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

first 4 bytes of q: ABCD

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

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

01Grow keeps the leading bytes

02Shrink keeps min(old, new) bytes

03NULL ptr behaves like malloc

04NULL ptr ignores old_size

05Grow preserves a short string and its NUL

06Shrink drops the tail past new_size

07Same-size resize preserves every byte

08Grown tail is the caller's to fill

mem_resize

Objective

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.

Steps

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.

examples

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

first 4 bytes of q: ABCD

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

first 4 bytes of q: ABCD

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

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 memory32

Objective

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.

Steps

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.

examples

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

first 4 bytes of q: ABCD

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

first 4 bytes of q: ABCD

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

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

01Grow keeps the leading bytes

02Shrink keeps min(old, new) bytes

03NULL ptr behaves like malloc

04NULL ptr ignores old_size

05Grow preserves a short string and its NUL

06Shrink drops the tail past new_size

07Same-size resize preserves every byte

08Grown tail is the caller's to fill