pub unsafe fn swap<T>(x: *mut T, y: *mut T)
Expand description
Swaps the values at two mutable locations of the same type, without deinitializing either.
But for the following exceptions, this function is semantically
equivalent to mem::swap
:

It operates on raw pointers instead of references. When references are available,
mem::swap
should be preferred. 
The two pointedto values may overlap. If the values do overlap, then the overlapping region of memory from
x
will be used. This is demonstrated in the second example below. 
The operation is “untyped” in the sense that data may be uninitialized or otherwise violate the requirements of
T
. The initialization state is preserved exactly.
Safety
Behavior is undefined if any of the following conditions are violated:

Both
x
andy
must be valid for both reads and writes. 
Both
x
andy
must be properly aligned.
Note that even if T
has size 0
, the pointers must be nonnull and properly aligned.
Examples
Swapping two nonoverlapping regions:
use std::ptr;
let mut array = [0, 1, 2, 3];
let (x, y) = array.split_at_mut(2);
let x = x.as_mut_ptr().cast::<[u32; 2]>(); // this is `array[0..2]`
let y = y.as_mut_ptr().cast::<[u32; 2]>(); // this is `array[2..4]`
unsafe {
ptr::swap(x, y);
assert_eq!([2, 3, 0, 1], array);
}
RunSwapping two overlapping regions:
use std::ptr;
let mut array: [i32; 4] = [0, 1, 2, 3];
let array_ptr: *mut i32 = array.as_mut_ptr();
let x = array_ptr as *mut [i32; 3]; // this is `array[0..3]`
let y = unsafe { array_ptr.add(1) } as *mut [i32; 3]; // this is `array[1..4]`
unsafe {
ptr::swap(x, y);
// The indices `1..3` of the slice overlap between `x` and `y`.
// Reasonable results would be for to them be `[2, 3]`, so that indices `0..3` are
// `[1, 2, 3]` (matching `y` before the `swap`); or for them to be `[0, 1]`
// so that indices `1..4` are `[0, 1, 2]` (matching `x` before the `swap`).
// This implementation is defined to make the latter choice.
assert_eq!([1, 0, 1, 2], array);
}
Run