50 lines
3.1 KiB
HTML
50 lines
3.1 KiB
HTML
<!DOCTYPE html>
|
||
<html lang="en">
|
||
<head>
|
||
<meta charset="UTF-8">
|
||
<title>Smart Pointers</title>
|
||
</head>
|
||
<body>
|
||
<h1 id="smart-pointers"><a class="header" href="#smart-pointers">Smart Pointers</a></h1>
|
||
<p>A pointer is a general concept for a variable that contains an address in
|
||
memory. This address refers to, or “points at,” some other data. The most
|
||
common kind of pointer in Rust is a reference, which you learned about in
|
||
Chapter 4. References are indicated by the <code>&</code> symbol and borrow the value they
|
||
point to. They don’t have any special capabilities other than referring to
|
||
data, and they have no overhead.</p>
|
||
<p><em>Smart pointers</em>, on the other hand, are data structures that act like a
|
||
pointer but also have additional metadata and capabilities. The concept of
|
||
smart pointers isn’t unique to Rust: Smart pointers originated in C++ and exist
|
||
in other languages as well. Rust has a variety of smart pointers defined in the
|
||
standard library that provide functionality beyond that provided by references.
|
||
To explore the general concept, we’ll look at a couple of different examples of
|
||
smart pointers, including a <em>reference counting</em> smart pointer type. This
|
||
pointer enables you to allow data to have multiple owners by keeping track of
|
||
the number of owners and, when no owners remain, cleaning up the data.</p>
|
||
<p>In Rust, with its concept of ownership and borrowing, there is an additional
|
||
difference between references and smart pointers: While references only borrow
|
||
data, in many cases smart pointers <em>own</em> the data they point to.</p>
|
||
<p>Smart pointers are usually implemented using structs. Unlike an ordinary
|
||
struct, smart pointers implement the <code>Deref</code> and <code>Drop</code> traits. The <code>Deref</code>
|
||
trait allows an instance of the smart pointer struct to behave like a reference
|
||
so that you can write your code to work with either references or smart
|
||
pointers. The <code>Drop</code> trait allows you to customize the code that’s run when an
|
||
instance of the smart pointer goes out of scope. In this chapter, we’ll discuss
|
||
both of these traits and demonstrate why they’re important to smart pointers.</p>
|
||
<p>Given that the smart pointer pattern is a general design pattern used
|
||
frequently in Rust, this chapter won’t cover every existing smart pointer. Many
|
||
libraries have their own smart pointers, and you can even write your own. We’ll
|
||
cover the most common smart pointers in the standard library:</p>
|
||
<ul>
|
||
<li><code>Box<T></code>, for allocating values on the heap</li>
|
||
<li><code>Rc<T></code>, a reference counting type that enables multiple ownership</li>
|
||
<li><code>Ref<T></code> and <code>RefMut<T></code>, accessed through <code>RefCell<T></code>, a type that enforces
|
||
the borrowing rules at runtime instead of compile time</li>
|
||
</ul>
|
||
<p>In addition, we’ll cover the <em>interior mutability</em> pattern where an immutable
|
||
type exposes an API for mutating an interior value. We’ll also discuss
|
||
reference cycles: how they can leak memory and how to prevent them.</p>
|
||
<p>Let’s dive in!</p>
|
||
</body>
|
||
</html>
|