mirror of
https://github.com/google/comprehensive-rust.git
synced 2024-11-29 02:12:05 +02:00
pt-BR: Update and Complete chapter 12 to 15.2 (#920)
* Translate chap 12 to 15.2 * Remove unicode chars
This commit is contained in:
João Victor Mendes
GitHub
parent
eef6906235
commit
2f6c4f2226
383
po/pt-BR.po
383
po/pt-BR.po
@ -5855,7 +5855,7 @@ msgstr ""
|
||||
|
||||
#: src/welcome-day-2.md:1
|
||||
msgid "# Welcome to Day 2"
|
||||
msgstr "# Bem-vindo ao dia 2"
|
||||
msgstr "# Bem-vindos ao Dia 2"
|
||||
|
||||
#: src/welcome-day-2.md:3
|
||||
msgid "Now that we have seen a fair amount of Rust, we will continue with:"
|
||||
@ -5875,6 +5875,17 @@ msgid ""
|
||||
"\n"
|
||||
"* Modules: visibility, paths, and filesystem hierarchy."
|
||||
msgstr ""
|
||||
"* Estruturas (structs), enumerações (enums), métodos (methods).\n"
|
||||
"\n"
|
||||
"* Correspondência de padrões: desestruturando enums, structs, e arrays.\n"
|
||||
"\n"
|
||||
"* Construtos de fluxo de controle: `if`, `if let`, `while`, `while let`, `break`, e\n"
|
||||
" `continue`.\n"
|
||||
"\n"
|
||||
"* A Biblioteca Padrão: `String`, `Option` e `Result`, `Vec`, `HashMap`, `Rc`\n"
|
||||
" e `Arc`.\n"
|
||||
"\n"
|
||||
"* Módulos: visibilidade, caminhos (paths), e hierarquia do sistema de arquivos."
|
||||
|
||||
#: src/structs.md:1
|
||||
msgid "# Structs"
|
||||
@ -5937,7 +5948,6 @@ msgid "Key Points:"
|
||||
msgstr "Pontos chave:"
|
||||
|
||||
#: src/structs.md:33
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Structs work like in C or C++.\n"
|
||||
" * Like in C++, and unlike in C, no typedef is needed to define a type.\n"
|
||||
@ -5951,19 +5961,14 @@ msgid ""
|
||||
"having to explicitly type it all out. It must always be the last element."
|
||||
msgstr ""
|
||||
"* Structs funcionam como em C ou C++.\n"
|
||||
" * Como em C++, e ao contrário de C, nenhum typedef é necessário para definir um tipo.\n"
|
||||
" * Ao contrário do C++, não há herança entre structs.\n"
|
||||
"* Os métodos são definidos em um bloco `impl`, que veremos nos próximos slides.\n"
|
||||
"* Este pode ser um bom momento para que as pessoas saibam que existem diferentes tipos de "
|
||||
"structs.\n"
|
||||
" * _Structs_ de tamanho zero `por exemplo, struct Foo;` podem ser usadas ao implementar uma "
|
||||
"característica em algum tipo,\n"
|
||||
"mas não possuem nenhum dado que você deseja armazenar nelas.\n"
|
||||
" * O próximo slide apresentará as estruturas tuplas (_Tuple Structs_) usadas quando o nome dos "
|
||||
"campos não são importantes.\n"
|
||||
"* A sintaxe `..pedro` permite a cópia da maioria do campos de uma _struct_ sem precisar explicitar "
|
||||
"seus tipos.\n"
|
||||
" Ele precisa ser o último elemento."
|
||||
" * Como em C++, e ao contrário de C, nenhum _`typedef`_ é necessário para definir um tipo.\n"
|
||||
" * Ao contrário do C++, não há herança entre _structs_.\n"
|
||||
"* Os métodos são definidos em um bloco _`impl`_, que veremos nos próximos slides.\n"
|
||||
"* Este pode ser um bom momento para que as pessoas saibam que existem diferentes tipos de _structs_.\n"
|
||||
" * _Structs_ de tamanho zero `por exemplo, struct Foo;` podem ser usadas ao implementar uma característica em algum tipo, mas não possuem nenhum dado que\n"
|
||||
"você deseja armazenar nelas.\n"
|
||||
" * O próximo slide apresentará as estruturas tuplas (_Estruturas Tupla_) usadas quando o nome dos campos não são importantes.\n"
|
||||
"* A sintaxe `..pedro` permite copiar a maioria dos campos de uma _struct_ sem precisar explicitar seus tipos. Sempre deve ser o último elemento."
|
||||
|
||||
#: src/structs/tuple-structs.md:1
|
||||
msgid "# Tuple Structs"
|
||||
@ -5974,7 +5979,6 @@ msgid "If the field names are unimportant, you can use a tuple struct:"
|
||||
msgstr "Se os nomes dos campos não forem importantes, você pode usar uma estrutura de tupla:"
|
||||
|
||||
#: src/structs/tuple-structs.md:5
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"```rust,editable\n"
|
||||
"struct Point(i32, i32);\n"
|
||||
@ -5985,6 +5989,9 @@ msgid ""
|
||||
"}\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
"```rust,editable\n"
|
||||
"struct Ponto(i32, i32);\n"
|
||||
"\n"
|
||||
"fn main() {\n"
|
||||
" let p = Ponto(17, 23);\n"
|
||||
" println!(\"({}, {})\", p.0, p.1);\n"
|
||||
@ -5993,7 +6000,7 @@ msgstr ""
|
||||
|
||||
#: src/structs/tuple-structs.md:14
|
||||
msgid "This is often used for single-field wrappers (called newtypes):"
|
||||
msgstr "Isso geralmente é usado para wrappers de campo único (chamados newtypes):"
|
||||
msgstr "Isso é comumente utilizado para _wrappers_ (invólucros) com campo único (chamados _newtypes_):"
|
||||
|
||||
#: src/structs/tuple-structs.md:16
|
||||
msgid ""
|
||||
@ -6016,9 +6023,26 @@ msgid ""
|
||||
"\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
"```rust,editable,compile_fail\n"
|
||||
"struct LibrasDeForca(f64);\n"
|
||||
"struct Newtons(f64);\n"
|
||||
"\n"
|
||||
"fn calcular_forca_nas_turbinas() -> LibrasDeForca {\n"
|
||||
" todo!(“Pergunte para um cientista de foguetes da NASA”)\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"fn definir_forca_nas_turbinas(force: Newtons) {\n"
|
||||
" // …\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"fn main() {\n"
|
||||
" let forca = calcular_forca_nas_turbinas();\n"
|
||||
" definir_forca_nas_turbinas(forca);\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"```"
|
||||
|
||||
#: src/structs/tuple-structs.md:37
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Newtypes are a great way to encode additional information about the value in a primitive type, "
|
||||
"for example:\n"
|
||||
@ -6033,25 +6057,25 @@ msgid ""
|
||||
"* The example is a subtle reference to the [Mars Climate Orbiter](https://en.wikipedia.org/wiki/"
|
||||
"Mars_Climate_Orbiter) failure."
|
||||
msgstr ""
|
||||
"Newtypes são uma ótima maneira de codificar informações adicionais sobre o valor em um tipo "
|
||||
"primitivo, por exemplo:\n"
|
||||
" * O número é medido em algumas unidades: `Newtons` no exemplo acima.\n"
|
||||
" * O valor passou por alguma validação quando foi criado, então você não precisa mais validá-lo "
|
||||
"novamente a cada uso: `PhoneNumber(String)` ou `OddNumber(u32)`.\n"
|
||||
" \n"
|
||||
"</details>"
|
||||
"_Newtypes_ são uma ótima maneira de codificar informações adicionais sobre o valor em um tipo primitivo, por exemplo:\n"
|
||||
" * O número é medido em alguma unidade: `Newtons` no exemplo acima.\n"
|
||||
" * O valor passou por alguma validação quando foi criado, então não é preciso validá-lo novamente a cada uso: `NumeroTelefone(String)` ou `NumeroImpar(u32)`.\n"
|
||||
"* Demonstre como somar um valor `f64` em um valor do tipo `Newtons` acessando o campo único do _newtype_.\n"
|
||||
" * Geralmente, Rust não gosta de coisas implícitas, como _unwrapping_ automático ou, por exemplo, usar booleanos como inteiros.\n"
|
||||
" * Sobrecarga de operadores é discutido no Dia 3 (_generics_).\n"
|
||||
"* O examplo é uma referência sutil a falha do [Orbitador Climático de Marte](https://pt.wikipedia.org/wiki/Mars_Climate_Orbiter)."
|
||||
|
||||
#: src/structs/field-shorthand.md:1
|
||||
msgid "# Field Shorthand Syntax"
|
||||
msgstr "# Sintaxe abreviada de campo"
|
||||
msgstr "# Sintaxe Abreviada de Campo"
|
||||
|
||||
#: src/structs/field-shorthand.md:3
|
||||
msgid ""
|
||||
"If you already have variables with the right names, then you can create the\n"
|
||||
"struct using a shorthand:"
|
||||
msgstr ""
|
||||
"Se você já tiver variáveis com os nomes corretos, poderá criar o\n"
|
||||
"struct usando uma abreviação:"
|
||||
"Se você já tiver variáveis com os nomes corretos, poderá criar a\n"
|
||||
"estrutura (_struct_) usando uma abreviação:"
|
||||
|
||||
#: src/structs/field-shorthand.md:6
|
||||
msgid ""
|
||||
@ -6074,6 +6098,24 @@ msgid ""
|
||||
"}\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
"```rust,editable\n"
|
||||
"#[derive(Debug)]\n"
|
||||
"struct Pessoa {\n"
|
||||
" nome: String,\n"
|
||||
" idade: u8,\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"impl Pessoa {\n"
|
||||
" fn new(nome: String, idade: u8) -> Pessoa {\n"
|
||||
" Pessoa { nome, idade }\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"fn main() {\n"
|
||||
" let pedro = Pessoa::new(String::from(\"Pedro\"), 27);\n"
|
||||
" println!(\"{pedro:?}\");\n"
|
||||
"}\n"
|
||||
"```"
|
||||
|
||||
#: src/structs/field-shorthand.md:27
|
||||
msgid ""
|
||||
@ -6125,6 +6167,50 @@ msgid ""
|
||||
"will no longer be accessible afterwards.\n"
|
||||
"* Use `{:#?}` when printing structs to request the `Debug` representation."
|
||||
msgstr ""
|
||||
"* A função `new` poderia ser escrita utilizando `Self` como tipo, já que ele é intercambiável com o nome da _struct_\n"
|
||||
"\n"
|
||||
" ```rust,editable\n"
|
||||
" #[derive(Debug)]\n"
|
||||
" struct Pessoa {\n"
|
||||
" nome: String,\n"
|
||||
" idade: u8,\n"
|
||||
" }\n"
|
||||
" impl Pessoa {\n"
|
||||
" fn new(nome: String, idade: u8) -> Self {\n"
|
||||
" Self { nome, idade }\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
" ``` \n"
|
||||
"* Implemente a _trait_ `Default` (Padrão) para a _struct_. Defina alguns campos e utilize valores padrão para os demais.\n"
|
||||
"\n"
|
||||
" ```rust,editable\n"
|
||||
" #[derive(Debug)]\n"
|
||||
" struct Pessoa {\n"
|
||||
" nome: String,\n"
|
||||
" idade: u8,\n"
|
||||
" }\n"
|
||||
" impl Default for Pessoa {\n"
|
||||
" fn default() -> Pessoa {\n"
|
||||
" Pessoa {\n"
|
||||
" nome: \"Robô\".to_string(),\n"
|
||||
" idade: 0,\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
" fn create_default() {\n"
|
||||
" let tmp = Pessoa {\n"
|
||||
" ..Default::default()\n"
|
||||
" };\n"
|
||||
" let tmp = Pessoa {\n"
|
||||
" nome: \"Sam\".to_string(),\n"
|
||||
" ..Default::default()\n"
|
||||
" };\n"
|
||||
" }\n"
|
||||
" ```\n"
|
||||
"\n"
|
||||
"* Métodos são definidos no bloco `impl`.\n"
|
||||
"* Use struct update syntax to define a new structure using `peter`. Note that the variable `peter` will no longer be accessible afterwards.\n"
|
||||
"* Utilize `{:#?}` para imprimir _structs_ para utilizar a representação `Debug` (de Depuração)."
|
||||
|
||||
#: src/enums.md:1
|
||||
msgid "# Enums"
|
||||
@ -6139,7 +6225,6 @@ msgstr ""
|
||||
"variações diferentes:"
|
||||
|
||||
#: src/enums.md:6
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"```rust,editable\n"
|
||||
"fn generate_random_number() -> i32 {\n"
|
||||
@ -6167,17 +6252,33 @@ msgid ""
|
||||
"}\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
"fn jogar_moeda() -> CaraCoroa {\n"
|
||||
" let numero_aleatorio = gerador_numero_aleatorio();\n"
|
||||
"```rust,editable\n"
|
||||
"fn gerar_numero_aleatorio() -> i32 {\n"
|
||||
" // Implementação baseada em https://xkcd.com/221/\n"
|
||||
" 4 // Escolhido por uma rolagem de dados justa. Garantido ser aleatório.\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"#[derive(Debug)]\n"
|
||||
"enum MoedaJogada {\n"
|
||||
" Cara,\n"
|
||||
" Coroa,\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"fn jogar_moeda() -> MoedaJogada {\n"
|
||||
" let numero_aleatorio = gerar_numero_aleatorio();\n"
|
||||
" if numero_aleatorio % 2 == 0 {\n"
|
||||
" return CaraCoroa::Cara;\n"
|
||||
" return MoedaJogada::Cara;\n"
|
||||
" } else {\n"
|
||||
" return CaraCoroa::Coroa;\n"
|
||||
" return MoedaJogada::Coroa;\n"
|
||||
" }\n"
|
||||
"}"
|
||||
"}\n"
|
||||
"\n"
|
||||
"fn main() {\n"
|
||||
" println!(\"Você tirou: {:?}\", jogar_moeda());\n"
|
||||
"}\n"
|
||||
"```"
|
||||
|
||||
#: src/enums.md:36
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Enumerations allow you to collect a set of values under one type\n"
|
||||
"* This page offers an enum type `CoinFlip` with two variants `Heads` and `Tail`. You might note "
|
||||
@ -6189,20 +6290,17 @@ msgid ""
|
||||
" * You could even implement the different variants of an enum with separate structs but then they "
|
||||
"wouldn’t be the same type as they would if they were all defined in an enum. "
|
||||
msgstr ""
|
||||
"* As enumerações permitem que você colete um conjunto de valores em um tipo\n"
|
||||
"* Esta página oferece um tipo de Enum `CoinFlip` com duas variantes `Heads` e `Tail`. Você pode "
|
||||
"observar o namespace ao usar variantes.\n"
|
||||
"* Este pode ser um bom momento para comparar Structs e Enums:\n"
|
||||
" * Em ambos, você pode ter uma versão simples sem campos (unit struct) ou uma com diferentes "
|
||||
"tipos de campos (variant payloads).\n"
|
||||
"* Enumerações permitem coletar um conjunto de valores em um tipo\n"
|
||||
"* Esta página oferece um tipo de _enum_ `MoedaJogada` com duas variantes `Cara` e `Coroa`. Você pode observar o _namespace_ ao usar variantes.\n"
|
||||
"* Este pode ser um bom momento para comparar _Structs_ e _Enums_:\n"
|
||||
" * Em ambos, você pode ter uma versão simples sem campos (_unit struct_, ou estrutura unitária) ou uma com diferentes tipos de campo.\n"
|
||||
" * Em ambos, as funções associadas são definidas dentro de um bloco `impl`.\n"
|
||||
" * Você pode até mesmo implementar as diferentes variantes de uma Enum com Structs separadas, mas "
|
||||
"elas não seriam do mesmo tipo que seriam se todas fossem definidas em uma Enum.\n"
|
||||
"</details>"
|
||||
" * Você pode até mesmo implementar as diferentes variantes de uma _Enum_ com _Structs_ separadas, mas elas não seriam do mesmo tipo, como seriam se todas "
|
||||
"fossem definidas em uma _Enum_. "
|
||||
|
||||
#: src/enums/variant-payloads.md:1
|
||||
msgid "# Variant Payloads"
|
||||
msgstr "# Variantes de carga útil (payloads)"
|
||||
msgstr "# Conteúdos Variantes"
|
||||
|
||||
#: src/enums/variant-payloads.md:3
|
||||
msgid ""
|
||||
@ -6210,7 +6308,7 @@ msgid ""
|
||||
"`match` statement to extract the data from each variant:"
|
||||
msgstr ""
|
||||
"Você pode definir enums mais ricos onde as variantes carregam dados. Você pode então usar a\n"
|
||||
"instrução `match` para extrair os dados de cada variante:"
|
||||
"instrução `match` (corresponder) para extrair os dados de cada variante:"
|
||||
|
||||
#: src/enums/variant-payloads.md:6
|
||||
msgid ""
|
||||
@ -6241,9 +6339,34 @@ msgid ""
|
||||
"}\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
"```rust,editable\n"
|
||||
"enum EventoWeb {\n"
|
||||
" CarregarPagina, // Variante sem conteúdo\n"
|
||||
" TeclaPressionada(char), // Variante tupla\n"
|
||||
" Clique { x: i64, y: i64 }, // Variante completa\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"#[rustfmt::skip]\n"
|
||||
"fn inspecionar(evento: EventoWeb) {\n"
|
||||
" match evento {\n"
|
||||
" EventoWeb::CarregarPagina => println!(\"página carregada\"),\n"
|
||||
" EventoWeb::TeclaPressionada(c) => println!(\"pressionou '{c}'\"),\n"
|
||||
" EventoWeb::Clique { x, y } => println!(\"clicou em x={x}, y={y}\"),\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"fn main() {\n"
|
||||
" let carregar = EventoWeb::CarregarPagina;\n"
|
||||
" let pressionar = EventoWeb::TeclaPressionada('x');\n"
|
||||
" let clicar = EventoWeb::Clique { x: 20, y: 80 };\n"
|
||||
"\n"
|
||||
" inspecionar(carregar);\n"
|
||||
" inspecionar(pressionar);\n"
|
||||
" inspecionar(clicar);\n"
|
||||
"}\n"
|
||||
"```"
|
||||
|
||||
#: src/enums/variant-payloads.md:35
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* The values in the enum variants can only be accessed after being pattern matched. The pattern "
|
||||
"binds references to the fields in the \"match arm\" after the `=>`.\n"
|
||||
@ -6263,13 +6386,20 @@ msgid ""
|
||||
"`struct Click { ... }`. The inlined version cannot implement traits, for example. \n"
|
||||
" "
|
||||
msgstr ""
|
||||
"* No exemplo acima, acessar o `char` em `KeyPress`, ou `x` e `y` em `Click` só funciona dentro de "
|
||||
"uma instrução `match`\n"
|
||||
" ou em uma expressão `if let`.\n"
|
||||
"* `match` inspeciona um campo discriminante oculto no `enum`.\n"
|
||||
"* É possível recuperar o campo discriminante chamando `std::mem::discriminant()`.\n"
|
||||
"* `WebEvent::Click { ... }` não é exatamente o mesmo que `WebEvent::Click(Click)` com um `struct "
|
||||
"Click { ... }` de nível superior. A versão embutida não pode implementar traits, por exemplo."
|
||||
"* Os valores nas variantes de uma _enum_ só podem ser acessados após uma correspondência de padrão. O padrão vincula referências aos campos no \"braço\" do "
|
||||
"_match_ após `=>`.\n"
|
||||
" * A expressão é comparada com os padrões de cima a baixo. Não existe _fall-through_ como em C ou C++.\n"
|
||||
" * A expressão _match_ possui um valor. O valor é o da última expressão executada em um \"braço\" do _match_.\n"
|
||||
" * Começando do topo, nós procuramos qual padrão corresponde ao valor, e então executamos o código após a flecha. Quando uma correspondência é encontrada, nós "
|
||||
"paramos. \n"
|
||||
"* Demonstre o que acontece quando a busca não abrange todas as possibilidades. Mencione a vantagem que o compilador do Rust oferece confirmando quando todos os "
|
||||
"casos foram tratados. \n"
|
||||
"* `match` inspeciona um campo discriminant escondido na `enum`.\n"
|
||||
"* É possível recuperar o discriminante chamando `std::mem::discriminant()`\n"
|
||||
" * Isso é útil, por exemplo, ao implementar `PartialEq` para _structs_ nas quais comparar valores de campos não afeta a igualdade.\n"
|
||||
"* `EventoWeb::Clique { ... }` não é exatamente o mesmo que `EventoWeb::Clique(Clique)` com uma `struct Clique { ... }` _top-level_. A versão no próprio local "
|
||||
"(_inline_) não permite implementar _traits_, por exemplo. \n"
|
||||
" "
|
||||
|
||||
#: src/enums/sizes.md:1
|
||||
msgid "# Enum Sizes"
|
||||
@ -6277,12 +6407,9 @@ msgstr "# Tamanhos de Enum"
|
||||
|
||||
#: src/enums/sizes.md:3
|
||||
msgid "Rust enums are packed tightly, taking constraints due to alignment into account:"
|
||||
msgstr ""
|
||||
"Enums, em Rust, são empacotados firmemente, levando em consideração as restrições devido ao "
|
||||
"alinhamento:"
|
||||
msgstr "Enums, em Rust, são empacotados firmemente, levando em consideração as restrições devido ao alinhamento:"
|
||||
|
||||
#: src/enums/sizes.md:5
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"```rust,editable\n"
|
||||
"use std::mem::{align_of, size_of};\n"
|
||||
@ -6304,12 +6431,25 @@ msgid ""
|
||||
"}\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
"```rust,editable\n"
|
||||
"use std::mem::{align_of, size_of};\n"
|
||||
"\n"
|
||||
"macro_rules! dbg_size {\n"
|
||||
" ($t:ty) => {\n"
|
||||
" println!(\"{}: tamano: {} byte(s), alinhamento: {} byte(s)\",\n"
|
||||
" println!(\"{}: tamanho {} bytes, alinhamento: {} bytes\",\n"
|
||||
" stringify!($t), size_of::<$t>(), align_of::<$t>());\n"
|
||||
" };\n"
|
||||
"}"
|
||||
"}\n"
|
||||
"\n"
|
||||
"enum Foo {\n"
|
||||
" A,\n"
|
||||
" B,\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"fn main() {\n"
|
||||
" dbg_size!(Foo);\n"
|
||||
"}\n"
|
||||
"```"
|
||||
|
||||
#: src/enums/sizes.md:25
|
||||
msgid "* See the [Rust Reference](https://doc.rust-lang.org/reference/type-layout.html)."
|
||||
@ -6444,6 +6584,129 @@ msgid ""
|
||||
" }\n"
|
||||
" ```"
|
||||
msgstr ""
|
||||
" * Internamente Rust utiliza um campo (discriminante) para saber qual a variante da _enum_.\n"
|
||||
"\n"
|
||||
" * É possível controlar a discriminante se necessário (e.g., para compatibilidade com C):\n"
|
||||
" \n"
|
||||
" ```rust,editable\n"
|
||||
" #[repr(u32)]\n"
|
||||
" enum Bar {\n"
|
||||
" A, // 0\n"
|
||||
" B = 10000,\n"
|
||||
" C, // 10001\n"
|
||||
" }\n"
|
||||
" \n"
|
||||
" fn main() {\n"
|
||||
" println!(\"A: {}\", Bar::A as u32);\n"
|
||||
" println!(\"B: {}\", Bar::B as u32);\n"
|
||||
" println!(\"C: {}\", Bar::C as u32);\n"
|
||||
" }\n"
|
||||
" ```\n"
|
||||
"\n"
|
||||
" Sem `repr`, o tipo da discriminante usa 2 bytes, porque 10001 cabe em 2\n"
|
||||
" bytes.\n"
|
||||
"\n"
|
||||
"\n"
|
||||
" * Tente outros tipos como\n"
|
||||
" \n"
|
||||
" * `dbg_size!(bool)`: tamanho 1 bytes, alinhamento: 1 bytes,\n"
|
||||
" * `dbg_size!(Option<bool>)`: tamanho 1 bytes, alinhamento: 1 bytes (otimização de nicho, seja abaixo),\n"
|
||||
" * `dbg_size!(&i32)`: tamanho 8 bytes, alinhamento: 8 bytes (em uma máquina de 64-bits),\n"
|
||||
" * `dbg_size!(Option<&i32>)`: tamanho 8 bytes, alinhamento: 8 bytes (otimização de ponteiro nulo, veja abaixo).\n"
|
||||
"\n"
|
||||
" * Otimização de nicho: Rust vai mesclar padrões de bits não utilizados na discriminante\n"
|
||||
" da _enum_.\n"
|
||||
"\n"
|
||||
" * Otimização de ponteiro nulo: para [alguns\n"
|
||||
" tipos](https://doc.rust-lang.org/std/option/#representation), o Rust garante\n"
|
||||
" que `size_of::<T>()` se iguala `size_of::<Option<T>>()`.\n"
|
||||
"\n"
|
||||
" Código de exemplo caso queira mostrar como a representação em bits *pode* ser na prática.\n"
|
||||
" É importante apontar que o compilador não oferece nenhuma garantia a respeito dessa representação, portanto isso é completamente inseguro.\n"
|
||||
"\n"
|
||||
" ```rust,editable\n"
|
||||
" use std::mem::transmute;\n"
|
||||
"\n"
|
||||
" macro_rules! dbg_bits {\n"
|
||||
" ($e:expr, $bit_type:ty) => {\n"
|
||||
" println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, $bit_type>($e));\n"
|
||||
" };\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" fn main() {\n"
|
||||
" // TOTALMENTE INSEGURO. Rust não oferece nenhuma garantia sobre a\n"
|
||||
" // representação dos tipos em bits.\n"
|
||||
" unsafe {\n"
|
||||
" println!(\"Representação em bits de booleano\");\n"
|
||||
" dbg_bits!(false, u8);\n"
|
||||
" dbg_bits!(true, u8);\n"
|
||||
"\n"
|
||||
" println!(\"Representação em bits de Option<bool>\");\n"
|
||||
" dbg_bits!(None::<bool>, u8);\n"
|
||||
" dbg_bits!(Some(false), u8);\n"
|
||||
" dbg_bits!(Some(true), u8);\n"
|
||||
"\n"
|
||||
" println!(\"Representação em bits de Option<Option<bool>>\");\n"
|
||||
" dbg_bits!(Some(Some(false)), u8);\n"
|
||||
" dbg_bits!(Some(Some(true)), u8);\n"
|
||||
" dbg_bits!(Some(None::<bool>), u8);\n"
|
||||
" dbg_bits!(None::<Option<bool>>, u8);\n"
|
||||
"\n"
|
||||
" println!(\"Representação em bits de Option<&i32>\");\n"
|
||||
" dbg_bits!(None::<&i32>, usize);\n"
|
||||
" dbg_bits!(Some(&0i32), usize);\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
" ```\n"
|
||||
"\n"
|
||||
" Exemplo mais complexo caso queira demonstrar o que acontece ao encadear mais de 256 `Option`s de uma vez.\n"
|
||||
"\n"
|
||||
" ```rust,editable\n"
|
||||
" #![recursion_limit = \"1000\"]\n"
|
||||
"\n"
|
||||
" use std::mem::transmute;\n"
|
||||
" \n"
|
||||
" macro_rules! dbg_bits {\n"
|
||||
" ($e:expr, $bit_type:ty) => {\n"
|
||||
" println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, $bit_type>($e));\n"
|
||||
" };\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" // Macro que envolve um valor em 2^n Some() no qual n é o número de \"@\".\n"
|
||||
" // É preciso aumentar o limite de recursão para aplicar essa macro.\n"
|
||||
" macro_rules! muitos_options {\n"
|
||||
" ($value:expr) => { Some($value) };\n"
|
||||
" ($value:expr, @) => {\n"
|
||||
" Some(Some($value))\n"
|
||||
" };\n"
|
||||
" ($value:expr, @ $($more:tt)+) => {\n"
|
||||
" muitos_options!(muitos_options!($value, $($more)+), $($more)+)\n"
|
||||
" };\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" fn main() {\n"
|
||||
" // TOTALMENTE INSEGURO. Rust não oferece nenhuma garantia sobre a\n"
|
||||
" // representação dos tipos em bits.\n"
|
||||
" unsafe {\n"
|
||||
" assert_eq!(muitos_options!(false), Some(false));\n"
|
||||
" assert_eq!(muitos_options!(false, @), Some(Some(false)));\n"
|
||||
" assert_eq!(muitos_options!(false, @@), Some(Some(Some(Some(false)))));\n"
|
||||
"\n"
|
||||
" println!(\"Representação em bits de uma sequência de 128 Option's.\");\n"
|
||||
" dbg_bits!(muitos_options!(false, @@@@@@@), u8);\n"
|
||||
" dbg_bits!(muitos_options!(true, @@@@@@@), u8);\n"
|
||||
"\n"
|
||||
" println!(\"Representação em bits de uma sequência de 256 Option's.\");\n"
|
||||
" dbg_bits!(muitos_options!(false, @@@@@@@@), u16);\n"
|
||||
" dbg_bits!(muitos_options!(true, @@@@@@@@), u16);\n"
|
||||
"\n"
|
||||
" println!(\"Representação em bits de uma sequência de 257 Option's.\");\n"
|
||||
" dbg_bits!(muitos_options!(Some(false), @@@@@@@@), u16);\n"
|
||||
" dbg_bits!(muitos_options!(Some(true), @@@@@@@@), u16);\n"
|
||||
" dbg_bits!(muitos_options!(None::<bool>, @@@@@@@@), u16);\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
" ```"
|
||||
|
||||
#: src/methods.md:3
|
||||
msgid ""
|
||||
|
||||
Loading…
Reference in New Issue
Block a user