2017-02-18 18:41:16 +08:00
<!DOCTYPE HTML>
< html lang = "en" >
< head >
< meta charset = "UTF-8" >
2017-02-26 15:11:54 +08:00
< title > 结构体 - Rust 程序设计语言 简体中文版< / title >
2017-02-18 18:41:16 +08:00
< meta content = "text/html; charset=utf-8" http-equiv = "Content-Type" >
2017-02-26 15:11:54 +08:00
< meta name = "description" content = "Rust 程序设计语言 简体中文版" >
2017-02-18 18:41:16 +08:00
< meta name = "viewport" content = "width=device-width, initial-scale=1" >
< base href = "" >
< link rel = "stylesheet" href = "book.css" >
< link href = 'https://fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,600italic,700italic,800italic,400,300,600,700,800' rel = 'stylesheet' type = 'text/css' >
< link rel = "shortcut icon" href = "favicon.png" >
<!-- Font Awesome -->
< link rel = "stylesheet" href = "https://maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css" >
< link rel = "stylesheet" href = "highlight.css" >
< link rel = "stylesheet" href = "tomorrow-night.css" >
<!-- MathJax -->
< script type = "text/javascript" src = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" > < / script >
<!-- Fetch JQuery from CDN but have a local fallback -->
< script src = "https://code.jquery.com/jquery-2.1.4.min.js" > < / script >
< script >
if (typeof jQuery == 'undefined') {
document.write(unescape("%3Cscript src='jquery.js'%3E%3C/script%3E"));
}
< / script >
< / head >
< body class = "light" >
<!-- Set the theme before any content is loaded, prevents flash -->
< script type = "text/javascript" >
var theme = localStorage.getItem('theme');
if (theme == null) { theme = 'light'; }
$('body').removeClass().addClass(theme);
< / script >
<!-- Hide / unhide sidebar before it is displayed -->
< script type = "text/javascript" >
var sidebar = localStorage.getItem('sidebar');
if (sidebar === "hidden") { $("html").addClass("sidebar-hidden") }
else if (sidebar === "visible") { $("html").addClass("sidebar-visible") }
< / script >
< div id = "sidebar" class = "sidebar" >
2017-04-18 14:55:09 +08:00
< ul class = "chapter" > < li > < a href = "ch01-00-introduction.html" > < strong > 1.< / strong > 介绍< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch01-01-installation.html" > < strong > 1.1.< / strong > 安装< / a > < / li > < li > < a href = "ch01-02-hello-world.html" > < strong > 1.2.< / strong > Hello, World!< / a > < / li > < / ul > < / li > < li > < a href = "ch02-00-guessing-game-tutorial.html" > < strong > 2.< / strong > 猜猜看教程< / a > < / li > < li > < a href = "ch03-00-common-programming-concepts.html" > < strong > 3.< / strong > 通用编程概念< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch03-01-variables-and-mutability.html" > < strong > 3.1.< / strong > 变量和可变性< / a > < / li > < li > < a href = "ch03-02-data-types.html" > < strong > 3.2.< / strong > 数据类型< / a > < / li > < li > < a href = "ch03-03-how-functions-work.html" > < strong > 3.3.< / strong > 函数如何工作< / a > < / li > < li > < a href = "ch03-04-comments.html" > < strong > 3.4.< / strong > 注释< / a > < / li > < li > < a href = "ch03-05-control-flow.html" > < strong > 3.5.< / strong > 控制流< / a > < / li > < / ul > < / li > < li > < a href = "ch04-00-understanding-ownership.html" > < strong > 4.< / strong > 认识所有权< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch04-01-what-is-ownership.html" > < strong > 4.1.< / strong > 什么是所有权< / a > < / li > < li > < a href = "ch04-02-references-and-borrowing.html" > < strong > 4.2.< / strong > 引用 & 借用< / a > < / li > < li > < a href = "ch04-03-slices.html" > < strong > 4.3.< / strong > Slices< / a > < / li > < / ul > < / li > < li > < a href = "ch05-00-structs.html" class = "active" > < strong > 5.< / strong > 结构体< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch05-01-method-syntax.html" > < strong > 5.1.< / strong > 方法语法< / a > < / li > < / ul > < / li > < li > < a href = "ch06-00-enums.html" > < strong > 6.< / strong > 枚举和模式匹配< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch06-01-defining-an-enum.html" > < strong > 6.1.< / strong > 定义枚举< / a > < / li > < li > < a href = "ch06-02-match.html" > < strong > 6.2.< / strong > < code > match< / code > 控制流运算符< / a > < / li > < li > < a href = "ch06-03-if-let.html" > < strong > 6.3.< / strong > < code > if let< / code > 简单控制流< / a > < / li > < / ul > < / li > < li > < a href = "ch07-00-modules.html" > < strong > 7.< / strong > 模块< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch07-01-mod-and-the-filesystem.html" > < strong > 7.1.< / strong > < code > mod< / code > 和文件系统< / a > < / li > < li > < a href = "ch07-02-controlling-visibility-with-pub.html" > < strong > 7.2.< / strong > 使用< code > pub< / code > 控制可见性< / a > < / li > < li > < a href = "ch07-03-importing-names-with-use.html" > < strong > 7.3.< / strong > 使用< code > use< / code > 导入命名< / a > < / li > < / ul > < / li > < li > < a href = "ch08-00-common-collections.html" > < strong > 8.< / strong > 通用集合类型< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch08-01-vectors.html" > < strong > 8.1.< / strong > vector< / a > < / li > < li > < a href = "ch08-02-strings.html" > < strong > 8.2.< / strong > 字符串< / a > < / li > < li > < a href = "ch08-03-hash-maps.html" > < strong > 8.3.< / strong > 哈希 map< / a > < / li > < / ul > < / li > < li > < a href = "ch09-00-error-handling.html" > < strong > 9.< / strong > 错误处理< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch09-01-unrecoverable-errors-with-panic.html" > < strong > 9.1.< / strong > < code > panic!< / code > 与不可恢复的错误< / a > < / li > < li > < a href = "ch09-02-recoverable-errors-with-result.html" > < strong > 9.2.< / strong > < code > Result< / code > 与可恢复的错误< / a > < / li > < li > < a href = "ch09-03-to-panic-or-not-to-panic.html" > < strong > 9.3.< / strong > < code > panic!< / code > 还是不< code > panic!< / code > < / a > < / li > < / ul > < / li > < li > < a href = "ch10-00-generics.html" > < strong > 10.< / strong > 泛型、trait 和生命周期< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch10-01-syntax.html" > < strong > 10.1.< / strong > 泛型数据类型< / a > < / li > < li > < a href = "ch10-02-traits.html" > < strong > 10.2.< / strong > trait： < / a > < / li > < li > < a href = "ch10-03-lifetime-syntax.html" > < strong > 10.3.< / strong > 生命周期与引用有效性< / a > < / li > < / ul > < / li > < li > < a href = "ch11-00-testing.html" > < strong > 11.< / strong > 测试< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch11-01-writing-tests.html" > < strong > 11.1.< / strong > 编写测试< / a > < / li > < li > < a href = "ch11-02-running-tests.html" > < strong > 11.2.< / strong > 运行测试< / a > < / li > < li > < a href = "ch11-03-test-organization.html" > < strong > 11.3.< / strong > 测试的组织结构< / a > < / li > < / ul > < / li > < li > < a href = "ch12-00-
2017-02-18 18:41:16 +08:00
< / div >
< div id = "page-wrapper" class = "page-wrapper" >
< div class = "page" >
< div id = "menu-bar" class = "menu-bar" >
< div class = "left-buttons" >
< i id = "sidebar-toggle" class = "fa fa-bars" > < / i >
< i id = "theme-toggle" class = "fa fa-paint-brush" > < / i >
< / div >
2017-02-26 15:11:54 +08:00
< h1 class = "menu-title" > Rust 程序设计语言 简体中文版< / h1 >
2017-02-18 18:41:16 +08:00
< div class = "right-buttons" >
< i id = "print-button" class = "fa fa-print" title = "Print this book" > < / i >
< / div >
< / div >
< div id = "content" class = "content" >
2017-02-26 15:11:54 +08:00
< a class = "header" href = "#结构体" name = "结构体" > < h1 > 结构体< / h1 > < / a >
2017-02-18 18:41:16 +08:00
< blockquote >
2017-03-22 23:21:49 +08:00
< p > < a href = "https://github.com/rust-lang/book/blob/master/second-edition/src/ch05-00-structs.md" > ch05-00-structs.md< / a >
2017-02-18 18:41:16 +08:00
< br >
2017-03-20 23:47:47 +08:00
commit 3f2a1bd8dbb19cc48b210fc4fb35c305c8d81b56< / p >
2017-02-18 18:41:16 +08:00
< / blockquote >
2017-03-20 23:47:47 +08:00
< p > < code > struct< / code > ，是 < em > structure< / em > 的缩写，是一个允许我们命名并将多个相关值包装进一个有意义的组合的自定义类型。如果你来自一个面向对象编程语言背景，< code > struct< / code > 就像对象中的数据属性（字段）。在这一章的下一部分会讲到如何在结构体上定义方法；方法是如何为结构体数据指定< strong > 行为< / strong > 的函数。< code > struct< / code > 和< code > enum< / code > （将在第六章讲到）是为了充分利用 Rust 的编译时类型检查来在程序范围内创建新类型的基本组件。< / p >
< p > 对结构体的一种看法是他们与元组类似，这个我们在第三章讲过了。就像元组，结构体的每一部分可以是不同类型。可以命名各部分数据以便能更清楚的知道其值的意义。由于有了这些名字使得结构体更灵活：不需要依赖顺序来指定或访问实例中的值。< / p >
< p > 为了定义结构体，通过< code > struct< / code > 关键字并为整个结构体提供一个名字。结构体的名字需要描述它所组合的数据的意义。接着，在大括号中，定义每一部分数据的名字，他们被称作< strong > 字段< / strong > （ < em > field< / em > ），并定义字段类型。例如，列表 5-1 展示了一个储存用户账号信息的结构体：< / p >
2017-02-18 18:41:16 +08:00
< pre > < code class = "language-rust" > struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}
< / code > < / pre >
2017-03-20 23:47:47 +08:00
< p > < span class = "caption" > Listing 5-1: A < code > User< / code > struct definition< / span > < / p >
< p > 一旦定义了结构体后为了使用它，通过为每个字段指定具体值来创建这个结构体的< strong > 实例< / strong > 。创建一个实例需要以结构体的名字开头，接着在大括号中使用< code > key: value< / code > 对的形式提供字段，其中 key 是字段的名字而 value 是需要储存在字段中的数据值。这时字段的顺序并不必要与在结构体中声明他们的顺序一致。换句话说，结构体的定义就像一个这个类型的通用模板，而实例则会在这个模板中放入特定数据来创建这个类型的值。例如，我们可以像这样来声明一个特定的用户：< / p >
2017-02-18 18:41:16 +08:00
< pre > < code class = "language-rust" > # struct User {
# username: String,
# email: String,
# sign_in_count: u64,
# active: bool,
# }
#
let user1 = User {
email: String::from(" someone@example.com" ),
username: String::from(" someusername123" ),
active: true,
sign_in_count: 1,
};
< / code > < / pre >
< p > 为了从结构体中获取某个值，可以使用点号。如果我们只想要用户的邮箱地址，可以用< code > user1.email< / code > 。< / p >
2017-02-26 15:11:54 +08:00
< a class = "header" href = "#结构体数据的所有权" name = "结构体数据的所有权" > < h2 > 结构体数据的所有权< / h2 > < / a >
2017-02-18 18:41:16 +08:00
< p > 在列表 5-1 中的< code > User< / code > 结构体的定义中，我们使用了自身拥有所有权的< code > String< / code > 类型而不是< code > & str< / code > 字符串 slice 类型。这是一个有意而为之的选择，因为我们想要这个结构体拥有它所有的数据，为此只要整个结构体是有效的话其数据也应该是有效的。< / p >
< p > 可以使结构体储存被其他对象拥有的数据的引用，不过这么做的话需要用上< strong > 生命周期< / strong > （ < em > lifetimes< / em > ），这是第十章会讨论的一个 Rust 的功能。生命周期确保结构体引用的数据有效性跟结构体本身保持一致。如果你尝试在结构体中储存一个引用而不指定生命周期，比如这样：< / p >
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
< pre > < code class = "language-rust,ignore" > struct User {
username: & str,
email: & str,
sign_in_count: u64,
active: bool,
}
fn main() {
let user1 = User {
email: " someone@example.com" ,
username: " someusername123" ,
active: true,
sign_in_count: 1,
};
}
< / code > < / pre >
< p > 编译器会抱怨它需要生命周期说明符：< / p >
< pre > < code > error[E0106]: missing lifetime specifier
-->
|
2 | username: & str,
| ^ expected lifetime parameter
error[E0106]: missing lifetime specifier
-->
|
3 | email: & str,
| ^ expected lifetime parameter
< / code > < / pre >
2017-05-15 08:27:11 +08:00
< p > 第十章会讲到如何修复这个问题以便在结构体中储存引用，不过现在，通过从像< code > & str< / code > 这样的引用切换到像< code > String< / code > 这类拥有所有权的类型来修改修改这个错误。< / p >
2017-02-26 15:11:54 +08:00
< a class = "header" href = "#一个示例程序" name = "一个示例程序" > < h2 > 一个示例程序< / h2 > < / a >
2017-02-18 18:41:16 +08:00
< p > 为了理解何时会需要使用结构体，让我们编写一个计算长方形面积的程序。我们会从单独的变量开始，接着重构程序直到使用结构体替代他们为止。< / p >
< p > 使用 Cargo 来创建一个叫做 < em > rectangles< / em > 的新二进制程序，它会获取一个长方形以像素为单位的长度和宽度并计算它的面积。列表 5-2 中是项目的 < em > src/main.rs< / em > 文件中为此实现的一个小程序：< / p >
2017-03-20 23:47:47 +08:00
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
2017-02-18 18:41:16 +08:00
< pre > < code class = "language-rust" > fn main() {
let length1 = 50;
let width1 = 30;
println!(
" The area of the rectangle is {} square pixels." ,
area(length1, width1)
);
}
fn area(length: u32, width: u32) -> u32 {
length * width
}
< / code > < / pre >
2017-03-20 23:47:47 +08:00
< p > < span class = "caption" > Listing 5-2: Calculating the area of a rectangle
specified by its length and width in separate variables< / span > < / p >
2017-02-18 18:41:16 +08:00
< p > 尝试使用< code > cargo run< / code > 运行程序：< / p >
< pre > < code > The area of the rectangle is 1500 square pixels.
< / code > < / pre >
2017-02-26 15:11:54 +08:00
< a class = "header" href = "#使用元组重构" name = "使用元组重构" > < h3 > 使用元组重构< / h3 > < / a >
2017-03-20 23:47:47 +08:00
< p > 我们的小程序能正常运行；它调用< code > area< / code > 函数用长方形的每个维度来计算出面积。不过我们可以做的更好。长度和宽度是相关联的，因为他们在一起才能定义一个长方形。< / p >
2017-02-18 18:41:16 +08:00
< p > 这个做法的问题突显在< code > area< / code > 的签名上：< / p >
< pre > < code class = "language-rust,ignore" > fn area(length: u32, width: u32) -> u32 {
< / code > < / pre >
< p > 函数< code > area< / code > 本应该计算一个长方形的面积，不过函数却有两个参数。这两个参数是相关联的，不过程序自身却哪里也没有表现出这一点。将长度和宽度组合在一起将更易懂也更易处理。< / p >
< p > 第三章已经讨论过了一种可行的方法：元组。列表 5-3 是一个使用元组的版本：< / p >
2017-03-20 23:47:47 +08:00
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
2017-02-18 18:41:16 +08:00
< pre > < code class = "language-rust" > fn main() {
let rect1 = (50, 30);
println!(
" The area of the rectangle is {} square pixels." ,
area(rect1)
);
}
fn area(dimensions: (u32, u32)) -> u32 {
dimensions.0 * dimensions.1
}
< / code > < / pre >
2017-03-20 23:47:47 +08:00
< p > < span class = "caption" > Listing 5-3: Specifying the length and width of the
rectangle with a tuple< / span > < / p >
2017-02-18 18:41:16 +08:00
<!-- I will add ghosting & wingdings once we're in libreoffice /Carol -->
2017-03-20 23:47:47 +08:00
< p > 在某种程度上说这样好一点了。元组帮助我们增加了一些结构性，现在在调用< code > area< / code > 的时候只用传递一个参数。不过另一方面这个方法却更不明确了：元组并没有给出它元素的名称，所以计算变得更费解了，因为不得不使用索引来获取元组的每一部分：< / p >
2017-02-18 18:41:16 +08:00
<!-- I will change this to use wingdings instead of repeating this code once
we're in libreoffice /Carol -->
< pre > < code class = "language-rust,ignore" > dimensions.0 * dimensions.1
< / code > < / pre >
2017-03-20 23:47:47 +08:00
< p > 在面积计算时混淆长宽并没有什么问题，不过当在屏幕上绘制长方形时就有问题了！我们将不得不记住元组索引< code > 0< / code > 是< code > length< / code > 而< code > 1< / code > 是< code > width< / code > 。如果其他人要使用这些代码，他们也不得不搞清楚后再记住他们。容易忘记或者混淆这些值而造成错误，因为我们没有表明代码中数据的意义。< / p >
2017-02-26 15:11:54 +08:00
< a class = "header" href = "#使用结构体重构增加更多意义" name = "使用结构体重构增加更多意义" > < h3 > 使用结构体重构：增加更多意义< / h3 > < / a >
2017-03-20 23:47:47 +08:00
< p > 现在引入结构体的时候了。我们可以将元组转换为一个有整体名称而且每个部分也有对应名字的数据类型，如列表 5-4 所示：< / p >
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
2017-02-18 18:41:16 +08:00
< pre > < code class = "language-rust" > struct Rectangle {
length: u32,
width: u32,
}
fn main() {
let rect1 = Rectangle { length: 50, width: 30 };
println!(
" The area of the rectangle is {} square pixels." ,
area(& rect1)
);
}
fn area(rectangle: & Rectangle) -> u32 {
rectangle.length * rectangle.width
}
< / code > < / pre >
2017-03-20 23:47:47 +08:00
< p > < span class = "caption" > Listing 5-4: Defining a < code > Rectangle< / code > struct< / span > < / p >
2017-02-18 18:41:16 +08:00
<!-- Will add ghosting & wingdings once we're in libreoffice /Carol -->
< p > 这里我们定义了一个结构体并称其为< code > Rectangle< / code > 。在< code > {}< / code > 中定义了字段< code > length< / code > 和< code > width< / code > ，都是< code > u32< / code > 类型的。接着在< code > main< / code > 中，我们创建了一个长度为 50 和宽度为 30 的< code > Rectangle< / code > 的具体实例。< / p >
< p > 函数< code > area< / code > 现在被定义为接收一个名叫< code > rectangle< / code > 的参数，它的类型是一个结构体< code > Rectangle< / code > 实例的不可变借用。第四章讲到过，我们希望借用结构体而不是获取它的所有权这样< code > main< / code > 函数就可以保持< code > rect1< / code > 的所有权并继续使用它，所以这就是为什么在函数签名和调用的地方会有< code > & < / code > 。< / p >
2017-04-10 16:25:42 +08:00
< p > < code > area< / code > 函数访问< code > Rectangle< / code > 的< code > length< / code > 和< code > width< / code > 字段。< code > area< / code > 的签名现在明确的表明了我们的意图：通过其< code > length< / code > 和< code > width< / code > 字段，计算一个< code > Rectangle< / code > 的面积，。这表明了长度和宽度是相互联系的，并为这些值提供了描述性的名称而不是使用元组的索引值< code > 0< / code > 和< code > 1< / code > 。结构体胜在更清晰明了。< / p >
2017-02-26 15:11:54 +08:00
< a class = "header" href = "#通过衍生-trait-增加实用功能" name = "通过衍生-trait-增加实用功能" > < h3 > 通过衍生 trait 增加实用功能< / h3 > < / a >
2017-02-18 18:41:16 +08:00
< p > 如果能够在调试程序时打印出< code > Rectangle< / code > 实例来查看其所有字段的值就更好了。列表 5-5 尝试像往常一样使用< code > println!< / code > 宏：< / p >
2017-03-20 23:47:47 +08:00
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
2017-02-18 18:41:16 +08:00
< pre > < code class = "language-rust,ignore" > struct Rectangle {
length: u32,
width: u32,
}
fn main() {
let rect1 = Rectangle { length: 50, width: 30 };
println!(" rect1 is {}" , rect1);
}
< / code > < / pre >
2017-03-20 23:47:47 +08:00
< p > < span class = "caption" > Listing 5-5: Attempting to print a < code > Rectangle< / code >
instance< / span > < / p >
2017-02-18 18:41:16 +08:00
< p > 如果运行代码，会出现带有如下核心信息的错误：< / p >
< pre > < code > error[E0277]: the trait bound `Rectangle: std::fmt::Display` is not satisfied
< / code > < / pre >
< p > < code > println!< / code > 宏能处理很多类型的格式，不过，< code > {}< / code > ，默认告诉< code > println!< / code > 使用称为< code > Display< / code > 的格式：直接提供给终端用户查看的输出。目前为止见过的基本类型都默认实现了< code > Display< / code > ，所以它就是向用户展示< code > 1< / code > 或其他任何基本类型的唯一方式。不过对于结构体，< code > println!< / code > 应该用来输出的格式是不明确的，因为这有更多显示的可能性：是否需要逗号？需要打印出结构体的< code > {}< / code > 吗？ ？ ， < code > Display< / code > 的实现。< / p >
< p > 但是如果我们继续阅读错误，将会发现这个有帮助的信息：< / p >
< pre > < code > note: `Rectangle` cannot be formatted with the default formatter; try using
`:?` instead if you are using a format string
< / code > < / pre >
< p > 让我们来试试！现在< code > println!< / code > 看起来像< code > println!(" rect1 is {:?}" , rect1);< / code > 这样。在< code > {}< / code > 中加入< code > :?< / code > 指示符告诉< code > println!< / code > 我们想要使用叫做< code > Debug< / code > 的输出格式。< code > Debug< / code > 是一个 trait， < / p >
< p > 让我们试试运行这个变化...见鬼了。仍然能看到一个错误：< / p >
< pre > < code > error: the trait bound `Rectangle: std::fmt::Debug` is not satisfied
< / code > < / pre >
< p > 虽然编译器又一次给出了一个有帮助的信息！< / p >
< pre > < code > note: `Rectangle` cannot be formatted using `:?`; if it is defined in your
crate, add `#[derive(Debug)]` or manually implement it
< / code > < / pre >
< p > Rust < strong > 确实< / strong > 包含了打印出调试信息的功能，不过我们必须为结构体显式选择这个功能。为此，在结构体定义之前加上< code > #[derive(Debug)]< / code > 注解，如列表 5-6 所示：< / p >
< pre > < code class = "language-rust" > #[derive(Debug)]
struct Rectangle {
length: u32,
width: u32,
}
fn main() {
let rect1 = Rectangle { length: 50, width: 30 };
println!(" rect1 is {:?}" , rect1);
}
< / code > < / pre >
2017-03-20 23:47:47 +08:00
< p > < span class = "caption" > Listing 5-6: Adding the annotation to derive the < code > Debug< / code >
trait and printing the < code > Rectangle< / code > instance using debug formatting< / span > < / p >
2017-02-18 18:41:16 +08:00
< p > 此时此刻运行程序，运行这个程序，不会有任何错误并会出现如下输出：< / p >
< pre > < code > rect1 is Rectangle { length: 50, width: 30 }
< / code > < / pre >
< p > 好极了！这不是最漂亮的输出，不过它显示这个实例的所有字段，毫无疑问这对调试有帮助。如果想要输出再好看和易读一点，这对更大的结构体会有帮助，可以将< code > println!< / code > 的字符串中的< code > {:?}< / code > 替换为< code > {:#?}< / code > 。如果在这个例子中使用了美化的调试风格的话，输出会看起来像这样：< / p >
< pre > < code > rect1 is Rectangle {
length: 50,
width: 30
}
< / code > < / pre >
< p > Rust 为我们提供了很多可以通过< code > derive< / code > 注解来使用的 trait， ， < / p >
< p > 我们的< code > area< / code > 函数是非常明确的————它只是计算了长方形的面积。如果这个行为与< code > Rectangle< / code > 结构体再结合得更紧密一些就更好了，因为这明显就是< code > Rectangle< / code > 类型的行为。现在让我们看看如何继续重构这些代码，来将< code > area< / code > 函数协调进< code > Rectangle< / code > 类型定义的< code > area< / code > < strong > 方法< / strong > 中。< / p >
< / div >
<!-- Mobile navigation buttons -->
< a href = "ch04-03-slices.html" class = "mobile-nav-chapters previous" >
< i class = "fa fa-angle-left" > < / i >
< / a >
< a href = "ch05-01-method-syntax.html" class = "mobile-nav-chapters next" >
< i class = "fa fa-angle-right" > < / i >
< / a >
< / div >
< a href = "ch04-03-slices.html" class = "nav-chapters previous" title = "You can navigate through the chapters using the arrow keys" >
< i class = "fa fa-angle-left" > < / i >
< / a >
< a href = "ch05-01-method-syntax.html" class = "nav-chapters next" title = "You can navigate through the chapters using the arrow keys" >
< i class = "fa fa-angle-right" > < / i >
< / a >
< / div >
<!-- Local fallback for Font Awesome -->
< script >
if ($(".fa").css("font-family") !== "FontAwesome") {
$('< link rel = "stylesheet" type = "text/css" href = "_FontAwesome/css/font-awesome.css" > ').prependTo('head');
}
< / script >
<!-- Livereload script (if served using the cli tool) -->
< script src = "highlight.js" > < / script >
< script src = "book.js" > < / script >
< / body >
< / html >
