| "id","perguntas","saidas"
|
| "1","Como declaro uma função em Rust?","```rust |
| fn soma(a: i32, b: i32) -> i32 { |
| a + b |
| } |
| |
| fn main() { |
| println!(""{}"", soma(3, 4)); // 7 |
| } |
| ``` |
| Em Rust, a última expressão sem `;` é o retorno. `i32` é o tipo inteiro de 32 bits. `println!` é uma macro, não uma função."
|
| "2","Como criar uma struct em Rust?","```rust |
| struct Pessoa { |
| nome: String, |
| idade: u32, |
| } |
| |
| impl Pessoa { |
| fn new(nome: String, idade: u32) -> Self { |
| Pessoa { nome, idade } |
| } |
| fn apresentar(&self) -> String { |
| format!(""Olá, sou {} e tenho {} anos"", self.nome, self.idade) |
| } |
| } |
| |
| fn main() { |
| let p = Pessoa::new(String::from(""Ana""), 25); |
| println!(""{}"", p.apresentar()); |
| } |
| ``` |
| `impl` bloco define métodos da struct. `&self` é uma referência imutável à instância."
|
| "3","Como trato erros em Rust com Result?","```rust |
| use std::fs::File; |
| use std::io::Read; |
| |
| fn ler_arquivo(caminho: &str) -> Result<String, std::io::Error> { |
| let mut f = File::open(caminho)?; |
| let mut conteudo = String::new(); |
| f.read_to_string(&mut conteudo)?; |
| Ok(conteudo) |
| } |
| |
| fn main() { |
| match ler_arquivo(""dados.txt"") { |
| Ok(c) => println!(""{}"", c), |
| Err(e) => eprintln!(""Erro: {}"", e), |
| } |
| } |
| ``` |
| `?` propaga o erro para o caller. `Result<T, E>` é o tipo padrão para operações que podem falhar."
|
| "4","Como faço um loop em Rust?","```rust |
| // Loop for |
| for i in 0..5 { |
| println!(""{}"", i); |
| } |
| |
| // Loop while |
| let mut n = 0; |
| while n < 3 { |
| println!(""{}"", n); |
| n += 1; |
| } |
| |
| // Loop infinito com break |
| let mut x = 0; |
| loop { |
| if x >= 10 { break; } |
| x += 1; |
| } |
| ``` |
| `0..5` é um range exclusivo (vai até 4). `0..=5` é inclusivo. `loop` roda até um `break`."
|
| "5","Como uso ownership e borrowing em Rust?","```rust |
| fn main() { |
| let s1 = String::from(""Olá""); |
| let s2 = s1.clone(); // clona o conteúdo |
| println!(""{} {}"", s1, s2); |
| |
| // Borrowing (empréstimo) |
| fn tamanho(s: &String) -> usize { |
| s.len() |
| } |
| let s3 = String::from(""Rust""); |
| println!(""{}"", tamanho(&s3)); |
| } |
| ``` |
| Por padrão, atribar move a ownership. Use `&` para emprestar sem transferir ownership. `.clone()` duplica dados."
|
| "6","Como trabalho com vectors em Rust?","```rust |
| let mut nums: Vec<i32> = Vec::new(); |
| nums.push(1); |
| nums.push(2); |
| nums.push(3); |
| |
| // Inicialização com valores |
| let frutas = vec![String::from(""maçã""), String::from(""uva"")]; |
| |
| // Iteração |
| for n in &nums { |
| println!(""{}"", n); |
| } |
| |
| // Acesso |
| println!(""{}"", nums[0]); // 1 |
| println!(""{}"", nums.get(0).unwrap()); // 1 |
| ``` |
| `Vec<T>` é o array dinâmico de Rust. `.get()` retorna `Option<&T>`, seguro contra access out-of-bounds."
|
| "7","Como criar enums com variantes em Rust?","```rust |
| enum Forma { |
| Circulo(f64), |
| Retangulo(f64, f64), |
| Quadrado(f64), |
| } |
| |
| impl Forma { |
| fn area(&self) -> f64 { |
| match self { |
| Forma::Circulo(r) => std::f64::consts::PI * r * r, |
| Forma::Retangulo(l, a) => l * a, |
| Forma::Quadrado(l) => l * l, |
| } |
| } |
| } |
| |
| fn main() { |
| let f = Forma::Circulo(2.0); |
| println!(""Área: {:.2}"", f.area()); |
| } |
| ``` |
| Enums em Rust são muito poderosos — variantes podem carregar dados. `match` faz pattern matching exaustivo."
|
| "8","Como criar e usar threads em Rust?","```rust |
| use std::thread; |
| use std::time::Duration; |
| |
| fn main() { |
| let handle = thread::spawn(|| { |
| for i in 1..5 { |
| println!(""Thread: {}"", i); |
| thread::sleep(Duration::from_millis(10)); |
| } |
| }); |
| |
| for i in 1..3 { |
| println!(""Main: {}"", i); |
| thread::sleep(Duration::from_millis(10)); |
| } |
| |
| handle.join().unwrap(); // espera a thread terminar |
| } |
| ``` |
| `thread::spawn` cria a thread; `.join()` bloqueia até terminar. Para compartilhar dados entre threads, use `Arc<Mutex<T>>`."
|
|
|
