unsafe_uninit_copy_n

def unsafe_uninit_copy_n[T: Copyable, //, *, overlapping: Bool](*, dest: Pointer[T], src: Pointer[T], count: Int)

Copy count values from src into memory at dest.

This function creates copies of count values from the source memory in the destination memory. After this call, both source and destination values are valid and initialized.

For types with trivial copy constructors, this is optimized to a single unsafe_memcpy (or unsafe_memmove when overlapping=True) operation. Otherwise, it calls unsafe_write() on each element.

The destination memory is treated as a raw span of bits to write to. Any existing values at dest are silently overwritten without being destroyed. For types with non-trivial destructors, this can cause memory leaks. Call unsafe_destroy_n() on the destination region first if it contains initialized values that need cleanup. For trivial types like Int, this is not a concern.

Safety:

• dest must point to a valid memory region with space for at least count elements of type T.
• src must point to a valid memory region containing at least count initialized elements of type T.
• If overlapping=False, the src and dest memory regions must not overlap. Overlapping regions with overlapping=False is undefined behavior.

Parameters:

• ​T (Copyable): The type of values to copy, which must be Copyable.
• ​overlapping (Bool): If False, the function assumes src and dest do not overlap and uses unsafe_memcpy. If True, the function handles an overlap safely, walking the elements back-to-front when dest sits above src.

Args:

• ​dest (Pointer[T]): Pointer to the destination memory region.
• ​src (Pointer[T]): Pointer to the source memory region. Must point to initialized values.
• ​count (Int): The number of elements to copy.