mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

auto merge of #16924 : steveklabnik/rust/manual_pointer_fix, r=pcwalton

Browse Source 
This was brought up in IRC: https://botbot.me/mozilla/rust/2014-08-30/?msg=20733803&page=26
This commit is contained in:
bors 2014-09-02 07:01:07 +00:00
commit 0ff7bac2d8
1 changed files with 8 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/doc/rust.md
View File

@ -3668,32 +3668,17 @@ let a: List<int> = Cons(7, box Cons(13, box Nil));
All pointers in Rust are explicit first-class values. All pointers in Rust are explicit first-class values.
They can be copied, stored into data structures, and returned from functions. They can be copied, stored into data structures, and returned from functions.
There are four varieties of pointer in Rust: There are two varieties of pointer in Rust:
* Owning pointers (`Box`)
: These point to owned heap allocations (or "boxes") in the shared, inter-task heap.
Each owned box has a single owning pointer; pointer and pointee retain a 1:1 relationship at all times.
Owning pointers are written `Box<content>`,
for example `Box<int>` means an owning pointer to an owned box containing an integer.
Copying an owned box is a "deep" operation:
it involves allocating a new owned box and copying the contents of the old box into the new box.
Releasing an owning pointer immediately releases its corresponding owned box.
* References (`&`) * References (`&`)
: These point to memory _owned by some other value_. : These point to memory _owned by some other value_.
References arise by (automatic) conversion from owning pointers, managed pointers, A reference type is written `&type` for some lifetime-variable `f`,
or by applying the borrowing operator `&` to some other value, or just `&'a type` when you need an explicit lifetime.
including [lvalues, rvalues or temporaries](#lvalues,-rvalues-and-temporaries).
A borrow expression is written `&content`.
A reference type is written `&'f type` for some lifetime-variable `f`,
or just `&type` when the lifetime can be elided;
for example `&int` means a reference to an integer.
Copying a reference is a "shallow" operation: Copying a reference is a "shallow" operation:
it involves only copying the pointer itself. it involves only copying the pointer itself.
Releasing a reference typically has no effect on the value it points to, Releasing a reference typically has no effect on the value it points to,
with the exception of temporary values, with the exception of temporary values, which are released when the last
which are released when the last reference to them is released. reference to them is released.
* Raw pointers (`*`) * Raw pointers (`*`)
: Raw pointers are pointers without safety or liveness guarantees. : Raw pointers are pointers without safety or liveness guarantees.
@ -3706,6 +3691,9 @@ There are four varieties of pointer in Rust:
they exist to support interoperability with foreign code, they exist to support interoperability with foreign code,
and writing performance-critical or low-level functions. and writing performance-critical or low-level functions.
The standard library contains addtional 'smart pointer' types beyond references
and raw pointers.
### Function types ### Function types
The function type constructor `fn` forms new function types. The function type constructor `fn` forms new function types.