Questões - Conceitos Comuns de Programação
01 - Como você escreveria um comentário de linha única em Rust?
Resposta
fn main() {
// Este é um comentário de linha única
}02 - Qual é a sintaxe para comentários de bloco em Rust?
Resposta
fn main() {
/*
Este é um comentário de
bloco que abrange várias
linhas.
*/
}03 - Você pode aninhar comentários de bloco em Rust? Dê um exemplo.
Resposta
fn main() {
/*
Início do comentário externo
/* Este é um comentário de bloco aninhado */
Fim do comentário externo
*/
}04 - Qual macro você usaria para imprimir texto na mesma linha, sem adicionar uma quebra de linha no final?
Resposta
fn main() {
print!("Imprimir sem adicionar uma nova linha no final!");
}05 - Qual macro você usaria para imprimir texto e adicionar automaticamente uma quebra de linha no final?
Resposta
fn main() {
println!("Imprimir e adicionar nova linha no final!");
}06 - Escreva um código que imprima “Hello” e “World” na mesma linha usando a macro print!.
Resposta
fn main() {
print!("Hello, ");
print!("World");
}07 - Como você insere uma quebra de linha explícita dentro de uma string que está sendo impressa com println!?
Resposta
fn main() {
println!("Primeira linha\nSegunda linha");
}08 - Que outras sequências de escape você pode usar em strings Rust? Dê exemplos de pelo menos 3.
Resposta
fn main() {
println!("Barra invertida: \\");
println!("Olá \"mundo\"");
println!(r"C:\Usuários\Snoopy\Documentos\");
}09 - Como você declara uma variável chamada score e atribui a ela o valor 100?
Resposta
fn main() {
let score = 100;
println!("Score: {}", score);
}10 - Escreva uma linha de código que declare uma variável cidade com o valor Recife e a imprima na tela.
Resposta
fn main() {
let cidade = "Recife";
println!("Cidade: {}", cidade);
}11 - O que acontece se você tentar usar uma variável antes de declará-la em Rust?
Resposta
fn main() {
// Isto causaria um erro de tempo de compilação:
println!("{}", x);
let x = 5;
} 12 - Você pode declarar uma variável sem inicializá-la em Rust? Se sim, mostre como usá-la com segurança.
Resposta
fn main() {
let x: i32;
x = 42;
println!("x = {}", x);
}13 - Declare uma variável mutável chamada contador inicializada com 0. Em seguida, escreva o código para alterar o valor para 5 e imprima.
Resposta
fn main() {
let mut contador = 0;
println!("Contador = {}", contador);
contador = 5;
println!("Contador = {}", contador);
}14 - O que acontece se você tentar modificar uma variável imutável em Rust?
Resposta
fn main() {
let x = 1;
x = 2;
println!("x = {}", x);
}15 - Como você declara uma constante chamada MAX_SPEED com o valor “9000” do tipo i32?
Resposta
const MAX_SPEED: i32 = 9000;
fn main() {
println!("Max Speed: {}", MAX_SPEED);
}16 - É possível alterar o valor de uma constante após sua declaração?
Resposta
const MAX_SPEED: i32 = 100;
fn main() {
MAX_SPEED = 200; // erro: cannot assign to this expression
}Não. Constantes são sempre imutáveis — a palavra-chave mut não pode ser usada com const de forma alguma. Qualquer tentativa de reatribuição resulta em erro de compilação.
17 - Quais são as principais diferenças entre constantes e variáveis imutáveis em Rust?
Resposta
const CONSTANTE_GLOBAL: i32 = 100;
fn main() {
let variavel_imutavel = 200;
println!("Constante: {}, Variável: {}", CONSTANTE_GLOBAL, variavel_imutavel);
// Constantes:
// - Sempre imutáveis: 'mut' não é permitido de forma alguma (nem como tentativa);
// - Tipo explícito obrigatório (ex: : i32);
// - Avaliadas em tempo de compilação;
// - Podem ser declaradas em escopo global (fora de funções).
// Variáveis Imutáveis (let):
// - Podem ser tornadas mutáveis com 'mut';
// - O tipo pode ser inferido;
// - Locais ao seu escopo;
// - Podem ser definidas como o resultado de qualquer expressão.
}18 - Como você usaria a macro format! para criar a string “O valor é: 42” a partir do número 42?
Resposta
fn main() {
let numero = 42;
let numero_formatado = format!("O valor é: {}", numero);
println!("{}", numero_formatado);
}19 - Como você pode formatar o número “7” para que ele seja exibido como “0007” usando format!?
Resposta
fn main() {
let numero = 7;
let numero_formatado = format!("{:04}", numero);
println!("{}", numero_formatado);
}20 - Como você formataria um número de ponto flutuante para mostrar exatamente 2 casas decimais?
Resposta
fn main() {
let pi = 3.14159265359;
println!("Pi: {:.2}", pi);
let pi_formatado = format!("{:.2}", pi);
println!("Pi: {}", pi_formatado);
}21 - Demonstre como usar argumentos posicionais em format strings.
Resposta
fn main() {
let nome = "Snoopy";
let idade = 8;
let cidade = "Califórnia";
// Argumentos posicionais
println!("{0} tem {1} anos e mora na {2}", nome, idade, cidade);
// Argumentos nomeados
println!("{nome} tem {idade} anos e mora na {cidade}");
// Misturado
println!("{} tem {idade} anos e mora na {cidade}", nome);
}22 - O que é shadowing em Rust? Explique com um exemplo de código e qual seria a saída.
Resposta
fn main() {
let x = 5;
println!("Primeiro x: {}", x);
let x = x + 1;
println!("Segundo x: {}", x);
let x = x * 2;
println!("Terceiro x: {}", x);
let x = "Olá";
println!("Quarto x: {}", x);
}23 - Qual será a saída do seguinte código?
fn main () {
let x = 5;
let x = x + 1;
{
let x = x * 2;
println!("O valor interno de x é: {}", x);
}
println!("O valor externo de x é: {}", x);
}Resposta
fn main() {
let x = 5;
let x = x + 1; // x = 6
{
let x = x * 2; // x = 12
println!("O valor interno de x é: {}", x); // Saida: 12
}
println!("O valor externo de x é: {}", x); // Saida: 6
}24 - Qual será a saída do seguinte código? Explique por quê.
fn main () {
let a = 10;
{
let b = 20;
println!("Dentro do bloco: a = {}, b = {}", a, b);
}
println!("Fora do bloco: b = {}", b);
}Resposta
fn main() {
let a = 10;
{
let b = 20;
println!("Dentro do bloco: a = {}, b = {}", a, b);
// Saida: Dentro do bloco: a = 10, b = 20
}
// println!("Fora do bloco: b = {}", b);
// Erro: b não está no escopo
}