1 % The Rust Pointer Guide
3 Rust's pointers are one of its more unique and compelling features. Pointers
4 are also one of the more confusing topics for newcomers to Rust. They can also
5 be confusing for people coming from other languages that support pointers, such
6 as C++. This guide will help you understand this important topic.
8 # You don't actually need pointers, use references
10 I have good news for you: you probably don't need to care about pointers,
11 especially as you're getting started. Think of it this way: Rust is a language
12 that emphasizes safety. Pointers, as the joke goes, are very pointy: it's easy
13 to accidentally stab yourself. Therefore, Rust is made in a way such that you
14 don't need them very often.
16 "But guide!" you may cry. "My co-worker wrote a function that looks like this:
19 fn succ(x: &int) -> int { *x + 1 }
22 So I wrote this code to try it out:
27 let succ_number = succ(number);
28 println!("{}", succ_number);
32 And now I get an error:
35 error: mismatched types: expected `&int` but found `<generic integer #0>` (expected &-ptr but found integral variable)
38 What gives? It needs a pointer! Therefore I have to use pointers!"
40 Turns out, you don't. All you need is a reference. Try this on for size:
43 # fn succ(x: &int) -> int { *x + 1 }
46 let succ_number = succ(&number);
47 println!("{}", succ_number);
51 It's that easy! One extra little `&` there. This code will run, and print `6`.
53 That's all you need to know. Your co-worker could have written the function
57 fn succ(x: int) -> int { x + 1 }
61 let succ_number = succ(number);
62 println!("{}", succ_number);
66 No pointers even needed. Then again, this is a simple example. I assume that
67 your real-world `succ` function is more complicated, and maybe your co-worker
68 had a good reason for `x` to be a pointer of some kind. In that case, references
69 are your best friend. Don't worry about it, life is too short.
73 Here are the use-cases for pointers. I've prefixed them with the name of the
74 pointer that satisfies that use-case:
76 1. Owned: `Box<Trait>` must be a pointer, because you don't know the size of the
77 object, so indirection is mandatory.
79 2. Owned: You need a recursive data structure. These can be infinite sized, so
80 indirection is mandatory.
82 3. Owned: A very, very, very rare situation in which you have a *huge* chunk of
83 data that you wish to pass to many methods. Passing a pointer will make this
84 more efficient. If you're coming from another language where this technique is
85 common, such as C++, please read "A note..." below.
87 4. Reference: You're writing a function, and you need a pointer, but you don't
88 care about its ownership. If you make the argument a reference, callers
89 can send in whatever kind they want.
91 5. Shared: You need to share data among tasks. You can achieve that via the
94 Five exceptions. That's it. Otherwise, you shouldn't need them. Be sceptical
95 of pointers in Rust: use them for a deliberate purpose, not just to make the
98 ## A note for those proficient in pointers
100 If you're coming to Rust from a language like C or C++, you may be used to
101 passing things by reference, or passing things by pointer. In some languages,
102 like Java, you can't even have objects without a pointer to them. Therefore, if
103 you were writing this Rust code:
106 # fn transform(p: Point) -> Point { p }
114 let p0 = Point { x: 5, y: 10};
115 let p1 = transform(p0);
121 I think you'd implement `transform` like this:
128 # let p0 = Point { x: 5, y: 10};
129 fn transform(p: &Point) -> Point {
130 Point { x: p.x + 1, y: p.y + 1}
134 let p1 = transform(&p0);
137 This does work, but you don't need to create those references! The better way to write this is simply:
146 fn transform(p: Point) -> Point {
147 Point { x: p.x + 1, y: p.y + 1}
151 let p0 = Point { x: 5, y: 10};
152 let p1 = transform(p0);
157 But won't this be inefficient? Well, that's a complicated question, but it's
158 important to know that Rust, like C and C++, store aggregate data types
159 'unboxed,' whereas languages like Java and Ruby store these types as 'boxed.'
160 For smaller structs, this way will be more efficient. For larger ones, it may
161 be less so. But don't reach for that pointer until you must! Make sure that the
162 struct is large enough by performing some tests before you add in the
163 complexity of pointers.
167 Owned pointers are the conceptually simplest kind of pointer in Rust. A rough
168 approximation of owned pointers follows:
170 1. Only one owned pointer may exist to a particular place in memory. It may be
171 borrowed from that owner, however.
173 2. The Rust compiler uses static analysis to determine where the pointer is in
174 scope, and handles allocating and de-allocating that memory. Owned pointers are
175 not garbage collected.
177 These two properties make for three use cases.
179 ## References to Traits
181 Traits must be referenced through a pointer, because the struct that implements
182 the trait may be a different size than a different struct that implements the
183 trait. Therefore, unboxed traits don't make any sense, and aren't allowed.
185 ## Recursive Data Structures
187 Sometimes, you need a recursive data structure. The simplest is known as a 'cons list':
193 Cons(T, Box<List<T>>),
197 let list: List<int> = Cons(1, box Cons(2, box Cons(3, box Nil)));
198 println!("{}", list);
205 Cons(1, box Cons(2, box Cons(3, box Nil)))
208 The inner lists _must_ be an owned pointer, because we can't know how many
209 elements are in the list. Without knowing the length, we don't know the size,
210 and therefore require the indirection that pointers offer.
214 This should almost never be a concern, but because creating an owned pointer
215 boxes its value, it therefore makes referring to the value the size of the box.
216 This may make passing an owned pointer to a function less expensive than
217 passing the value itself. Don't worry yourself with this case until you've
218 proved that it's an issue through benchmarks.
220 For example, this will work:
229 let a = Point { x: 10, y: 20 };
236 This struct is tiny, so it's fine. If `Point` were large, this would be more
246 let a = box Point { x: 10, y: 20 };
253 Now it'll be copying a pointer-sized chunk of memory rather than the whole
258 References are the third major kind of pointer Rust supports. They are
259 simultaneously the simplest and the most complicated kind. Let me explain:
260 references are considered 'borrowed' because they claim no ownership over the
261 data they're pointing to. They're just borrowing it for a while. So in that
262 sense, they're simple: just keep whatever ownership the data already has. For
271 fn compute_distance(p1: &Point, p2: &Point) -> f32 {
272 let x_d = p1.x - p2.x;
273 let y_d = p1.y - p2.y;
275 (x_d * x_d + y_d * y_d).sqrt()
279 let origin = &Point { x: 0.0, y: 0.0 };
280 let p1 = box Point { x: 5.0, y: 3.0 };
282 println!("{}", compute_distance(origin, p1));
286 This prints `5.83095189`. You can see that the `compute_distance` function
287 takes in two references, a reference to a value on the stack, and a reference
289 Of course, if this were a real program, we wouldn't have any of these pointers,
290 they're just there to demonstrate the concepts.
292 So how is this hard? Well, because we're ignoring ownership, the compiler needs
293 to take great care to make sure that everything is safe. Despite their complete
294 safety, a reference's representation at runtime is the same as that of
295 an ordinary pointer in a C program. They introduce zero overhead. The compiler
296 does all safety checks at compile time.
298 This theory is called 'region pointers' and you can read more about it
299 [here](http://www.cs.umd.edu/projects/cyclone/papers/cyclone-regions.pdf).
300 Region pointers evolved into what we know today as 'lifetimes'.
302 Here's the simple explanation: would you expect this code to compile?
311 Probably not. That's because you know that the name `x` is valid from where
312 it's declared to when it goes out of scope. In this case, that's the end of
313 the `main` function. So you know this code will cause an error. We call this
314 duration a 'lifetime'. Let's try a more complex example:
321 println!("Oh no: {}", y);
325 println!("Oh no: {}", x);
329 Here, we're borrowing a pointer to `x` inside of the `if`. The compiler, however,
330 is able to determine that that pointer will go out of scope without `x` being
331 mutated, and therefore, lets us pass. This wouldn't work:
340 println!("Oh no: {}", y);
344 println!("Oh no: {}", x);
351 test.rs:5:8: 5:10 error: cannot assign to `*x` because it is borrowed
354 test.rs:4:16: 4:18 note: borrow of `*x` occurs here
355 test.rs:4 let y = &x;
359 As you might guess, this kind of analysis is complex for a human, and therefore
360 hard for a computer, too! There is an entire [guide devoted to references
361 and lifetimes](guide-lifetimes.html) that goes into lifetimes in
362 great detail, so if you want the full details, check that out.
366 We've talked a lot about functions that accept various kinds of pointers, but
367 what about returning them? In general, it is better to let the caller decide
368 how to use a function's output, instead of assuming a certain type of pointer
371 What does that mean? Don't do this:
374 fn foo(x: Box<int>) -> Box<int> {
387 fn foo(x: Box<int>) -> int {
397 This gives you flexibility, without sacrificing performance.
399 You may think that this gives us terrible performance: return a value and then
400 immediately box it up ?! Isn't that the worst of both worlds? Rust is smarter
401 than that. There is no copy in this code. `main` allocates enough room for the
402 `box int`, passes a pointer to that memory into `foo` as `x`, and then `foo` writes
403 the value straight into that pointer. This writes the return value directly into
406 This is important enough that it bears repeating: pointers are not for optimizing
407 returning values from your code. Allow the caller to choose how they want to
412 * [Lifetimes guide](guide-lifetimes.html)