How to swap two numbers?

Question

I'm trying to swap two integers in Rust without any library.

fn main() {
    let mut a = 5;
    let mut b = 6;
    swap(&mut a, &mut b);
    println!("{}, {}", a, b); // expecting 6, 5
}

First I've tried:

fn swap(mut a: &mut u32, mut b: &mut u32) {
    (a, b) = (b, a); // destructuring assignments are not currently supported
}

Then:

fn swap(mut a: &mut u32, mut b: &mut u32) {
    let temp = a;
    a = b;
    b = temp;
}
// got error[E0623]: lifetime mismatch

Finally:

fn swap<'a>(mut a: &'a mut u32, mut b: &'a mut u32) {
    let temp = a;
    a = b;
    b = temp;
}
// still does not work; when this scope ends a and b in `main()` are still 5 and 6 respectively
// got warning: value assigned to `a` is never read (for `b` as well)

I don't know what's wrong; last implementation looks cumbersome to me but I think it should work as I am passing mutable reference to function, but it does not work.

You are assigning the references, not the referred to values. Try `temp=*a` and so on. — prog-fh, Oct 12 '20 at 15:19
Duplicate of [How to swap two variables?](https://stackoverflow.com/questions/31798737/how-to-swap-two-variables) — Herohtar, Oct 13 '20 at 04:44

score 7 · Answer 1 · answered Oct 12 '20 at 15:19

7

The efficient way:

use std::mem;

let mut x = 5;
let mut y = 42;

mem::swap(&mut x, &mut y);

assert_eq!(42, x);
assert_eq!(5, y);

https://doc.rust-lang.org/std/mem/fn.swap.html

answered Oct 12 '20 at 15:19

C14L

12,153
4
39
52

I wanted to do without standard library but thanks anyway. – 109149 Oct 12 '20 at 15:22
6

@109149, you could use [`core::mem::swap`](https://doc.rust-lang.org/core/mem/fn.swap.html) - it's from the core library – ForceBru Oct 12 '20 at 15:25
6

@109149 Please include such restrictions in your questions, so people don't risk wasting their time by failing to meet criteria that you didn't specify. – underscore_d Oct 12 '20 at 15:45
I see, I've modified it. – 109149 Oct 12 '20 at 15:59

score 4 · Accepted Answer · answered Oct 12 '20 at 15:20

You can dereference references:

fn swap(a: &mut u32, b: &mut u32) {
    let t: u32 = *a; // Read the integer with `*a`
    *a = *b; // Write to the reference with `*a = <stuff>`
    *b = t;
}

fn main() {
    let mut a = 6;
    let mut b = 7;
    
    println!("{}, {}", a, b);
    swap(&mut a, &mut b);
    println!("{}, {}", a, b);
}

Output:

6, 7
7, 6

Playground

Martin Gallagher · Answer 3 · 2020-10-12T17:00:34.100

2

For copyable types this is quite succinct (if you prefer not to use std::mem::swap:

fn swap<T: Copy>(a: T, b: T) -> (T, T) {
    (b, a)
}

fn main() {
    let (a, b) = (1, 2);
    let (a, b) = swap(a, b);

    println!("A: {}, B: {}", a, b);

    // Note you can also just do this
    let (a, b) = (b, a);

    println!("A: {}, B: {}", a, b);
}

edited Oct 12 '20 at 17:00

answered Oct 12 '20 at 16:34

Martin Gallagher

4,444
2
28
26

I don't really see the point of this answer. Swapping two variables only makes sense if you actually mutate existing variables. This creates two new variables which happen to have swapped names, but it doesn't mutate any existing variables. Instead of doing this, you can also just swap the names in the remainder of the function. – Sven Marnach Oct 12 '20 at 18:09

How to swap two numbers?

3 Answers3