View source code
Display the source code in std/algorithm/mutation.d from which this
page was generated on github.
Report a bug
If you spot a problem with this page, click here to create a
Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page.
Requires a signed-in GitHub account. This works well for small changes.
If you'd like to make larger changes you may want to consider using
local clone.
Function std.algorithm.mutation.swap
Swaps lhs
and rhs
. The instances lhs
and rhs
are moved in
memory, without ever calling opAssign
, nor any other function. T
need not be assignable at all to be swapped.
void swap(T)
(
ref T lhs,
ref T rhs
) pure nothrow @nogc @trusted
if (isBlitAssignable!T && !is(typeof(lhs .proxySwap(rhs))));
void swap(T)
(
ref T lhs,
ref T rhs
)
if (is(typeof(lhs .proxySwap(rhs))));
If lhs
and rhs
reference the same instance, then nothing is done.
lhs
and rhs
must be mutable. If T
is a struct or union, then
its fields must also all be (recursively) mutable.
Parameters
Name | Description |
---|---|
lhs | Data to be swapped with rhs . |
rhs | Data to be swapped with lhs . |
Example
// Swapping POD (plain old data) types:
int a = 42, b = 34;
swap(a, b);
assert(a == 34 && b == 42);
// Swapping structs with indirection:
static struct S { int x; char c; int[] y; }
S s1 = { 0, 'z', [ 1, 2 ] };
S s2 = { 42, 'a', [ 4, 6 ] };
swap(s1, s2);
writeln(s1 .x); // 42
writeln(s1 .c); // 'a'
writeln(s1 .y); // [4, 6]
writeln(s2 .x); // 0
writeln(s2 .c); // 'z'
writeln(s2 .y); // [1, 2]
// Immutables cannot be swapped:
immutable int imm1 = 1, imm2 = 2;
static assert(!__traits(compiles, swap(imm1, imm2)));
int c = imm1 + 0;
int d = imm2 + 0;
swap(c, d);
writeln(c); // 2
writeln(d); // 1
Example
// Non-copyable types can still be swapped.
static struct NoCopy
{
this(this) { assert(0); }
int n;
string s;
}
NoCopy nc1, nc2;
nc1 .n = 127; nc1 .s = "abc";
nc2 .n = 513; nc2 .s = "uvwxyz";
swap(nc1, nc2);
assert(nc1 .n == 513 && nc1 .s == "uvwxyz");
assert(nc2 .n == 127 && nc2 .s == "abc");
swap(nc1, nc1);
swap(nc2, nc2);
assert(nc1 .n == 513 && nc1 .s == "uvwxyz");
assert(nc2 .n == 127 && nc2 .s == "abc");
// Types containing non-copyable fields can also be swapped.
static struct NoCopyHolder
{
NoCopy noCopy;
}
NoCopyHolder h1, h2;
h1 .noCopy .n = 31; h1 .noCopy .s = "abc";
h2 .noCopy .n = 65; h2 .noCopy .s = null;
swap(h1, h2);
assert(h1 .noCopy .n == 65 && h1 .noCopy .s == null);
assert(h2 .noCopy .n == 31 && h2 .noCopy .s == "abc");
swap(h1, h1);
swap(h2, h2);
assert(h1 .noCopy .n == 65 && h1 .noCopy .s == null);
assert(h2 .noCopy .n == 31 && h2 .noCopy .s == "abc");
// Const types cannot be swapped.
const NoCopy const1, const2;
assert(const1 .n == 0 && const2 .n == 0);
static assert(!__traits(compiles, swap(const1, const2)));
Authors
License
Copyright © 1999-2022 by the D Language Foundation | Page generated by ddox.