Rust vs C++ 2026: Comparativo Completo | Rust Brasil

#include <iostream>
#include <vector>
#include <memory>

// Problema 1: Use-after-free (compila sem erros)
void uso_apos_liberacao() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    int* ptr = &vec[2];
    vec.push_back(6); // Pode realocar o vetor
    // ptr agora pode apontar para memória inválida!
    std::cout << *ptr << std::endl; // Undefined behavior
}

// Problema 2: Dangling reference (compila sem erros)
int& referencia_pendente() {
    int local = 42;
    return local; // Retorna referência para variável local
}

// Solução moderna com smart pointers
void codigo_seguro_cpp() {
    auto ptr = std::make_unique<int>(42);
    // auto copia = ptr; // Erro: unique_ptr não pode ser copiado
    auto movido = std::move(ptr);
    // ptr agora é nullptr
    if (movido) {
        std::cout << *movido << std::endl;
    }
}

fn main() {
    // Tentativa 1: O equivalente ao use-after-free é impedido
    let mut vec = vec![1, 2, 3, 4, 5];
    let ptr = &vec[2];
    // vec.push(6); // ERRO DE COMPILAÇÃO: não pode mutar vec
                     // enquanto ptr tem uma referência imutável
    println!("{}", ptr); // OK: usado antes de qualquer mutação
    vec.push(6);         // OK: ptr não é mais usado

    // Tentativa 2: Referência pendente é impossível
    // fn referencia_pendente() -> &i32 {
    //     let local = 42;
    //     &local // ERRO: local não vive o suficiente
    // }

    // Ownership funciona naturalmente
    let ptr = Box::new(42);
    // let copia = ptr; // Move ocorre aqui
    let movido = ptr;
    // println!("{}", ptr); // ERRO: ptr foi movido
    println!("{}", movido); // OK
}

use std::time::Instant;

fn crivo_eratostenes(limite: usize) -> Vec<usize> {
    let mut eh_primo = vec![true; limite + 1];
    eh_primo[0] = false;
    if limite > 0 {
        eh_primo[1] = false;
    }

    let mut p = 2;
    while p * p <= limite {
        if eh_primo[p] {
            let mut multiplo = p * p;
            while multiplo <= limite {
                eh_primo[multiplo] = false;
                multiplo += p;
            }
        }
        p += 1;
    }

    (2..=limite).filter(|&i| eh_primo[i]).collect()
}

fn main() {
    let inicio = Instant::now();
    let primos = crivo_eratostenes(10_000_000);
    let duracao = inicio.elapsed();

    println!("Encontrados {} primos", primos.len());
    println!("Tempo: {:?}", duracao);
    println!("Último primo: {}", primos.last().unwrap());
}

#include <iostream>
#include <vector>
#include <chrono>

std::vector<size_t> crivo_eratostenes(size_t limite) {
    std::vector<bool> eh_primo(limite + 1, true);
    eh_primo[0] = eh_primo[1] = false;

    for (size_t p = 2; p * p <= limite; ++p) {
        if (eh_primo[p]) {
            for (size_t multiplo = p * p; multiplo <= limite; multiplo += p) {
                eh_primo[multiplo] = false;
            }
        }
    }

    std::vector<size_t> primos;
    for (size_t i = 2; i <= limite; ++i) {
        if (eh_primo[i]) primos.push_back(i);
    }
    return primos;
}

int main() {
    auto inicio = std::chrono::high_resolution_clock::now();
    auto primos = crivo_eratostenes(10'000'000);
    auto duracao = std::chrono::high_resolution_clock::now() - inicio;

    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(duracao);
    std::cout << "Encontrados " << primos.size() << " primos" << std::endl;
    std::cout << "Tempo: " << ms.count() << "ms" << std::endl;
    std::cout << "Último primo: " << primos.back() << std::endl;

    return 0;
}

#include <iostream>
#include <concepts>
#include <vector>
#include <numeric>

// C++20 Concepts melhoraram bastante a situação
template<typename T>
concept Numerico = std::integral<T> || std::floating_point<T>;

template<Numerico T>
T soma_vetor(const std::vector<T>& vec) {
    return std::accumulate(vec.begin(), vec.end(), T{});
}

// Template especializado
template<typename T>
struct Ponto {
    T x, y;

    Ponto operator+(const Ponto& outro) const {
        return {x + outro.x, y + outro.y};
    }

    friend std::ostream& operator<<(std::ostream& os, const Ponto& p) {
        return os << "(" << p.x << ", " << p.y << ")";
    }
};

int main() {
    std::vector<int> inteiros = {1, 2, 3, 4, 5};
    std::vector<double> decimais = {1.1, 2.2, 3.3};

    std::cout << "Soma inteiros: " << soma_vetor(inteiros) << std::endl;
    std::cout << "Soma decimais: " << soma_vetor(decimais) << std::endl;

    Ponto<double> p1{1.0, 2.0};
    Ponto<double> p2{3.0, 4.0};
    std::cout << "Soma pontos: " << (p1 + p2) << std::endl;

    return 0;
}

use std::fmt::Display;
use std::ops::Add;
use std::iter::Sum;

// Trait bounds são explícitos e claros
fn soma_vetor<T: Sum + Copy>(vec: &[T]) -> T {
    vec.iter().copied().sum()
}

// Struct genérica com trait bounds
#[derive(Debug, Clone, Copy)]
struct Ponto<T> {
    x: T,
    y: T,
}

impl<T: Add<Output = T> + Copy> Add for Ponto<T> {
    type Output = Self;

    fn add(self, outro: Self) -> Self {
        Ponto {
            x: self.x + outro.x,
            y: self.y + outro.y,
        }
    }
}

impl<T: Display> std::fmt::Display for Ponto<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

fn main() {
    let inteiros = vec![1, 2, 3, 4, 5];
    let decimais = vec![1.1, 2.2, 3.3];

    println!("Soma inteiros: {}", soma_vetor(&inteiros));
    println!("Soma decimais: {}", soma_vetor(&decimais));

    let p1 = Ponto { x: 1.0, y: 2.0 };
    let p2 = Ponto { x: 3.0, y: 4.0 };
    println!("Soma pontos: {}", p1 + p2);
}

#include <iostream>
#include <fstream>
#include <string>
#include <expected>  // C++23

// Abordagem moderna com std::expected
std::expected<std::string, std::string> ler_arquivo(const std::string& caminho) {
    std::ifstream arquivo(caminho);
    if (!arquivo.is_open()) {
        return std::unexpected("Não foi possível abrir: " + caminho);
    }
    std::string conteudo(
        (std::istreambuf_iterator<char>(arquivo)),
        std::istreambuf_iterator<char>()
    );
    return conteudo;
}

int main() {
    auto resultado = ler_arquivo("config.txt");
    if (resultado) {
        std::cout << "Conteúdo: " << resultado.value() << std::endl;
    } else {
        std::cerr << "Erro: " << resultado.error() << std::endl;
    }
    return 0;
}

use std::fs;
use std::io;

fn ler_arquivo(caminho: &str) -> Result<String, io::Error> {
    fs::read_to_string(caminho)
}

fn processar_config() -> Result<String, Box<dyn std::error::Error>> {
    let conteudo = ler_arquivo("config.txt")?; // Propaga erro automaticamente
    let primeira_linha = conteudo
        .lines()
        .next()
        .ok_or("Arquivo vazio")?; // Converte Option em Result
    Ok(primeira_linha.to_uppercase())
}

fn main() {
    match processar_config() {
        Ok(valor) => println!("Configuração: {}", valor),
        Err(erro) => eprintln!("Erro: {}", erro),
    }
}

cargo new meu_projeto
cd meu_projeto
# Editar Cargo.toml para adicionar dependências
cargo build --release
cargo test
cargo doc --open

mkdir meu_projeto && cd meu_projeto
# Criar CMakeLists.txt manualmente
# Criar conanfile.txt para dependências
# Instalar dependências
conan install . --output-folder=build --build=missing
# Configurar e compilar
cmake --preset conan-release
cmake --build build/
# Testes requerem configuração adicional em CMakeLists.txt
ctest --test-dir build/

// Usando cxx para interoperabilidade Rust <-> C++
#[cxx::bridge]
mod ffi {
    // Funções C++ que Rust pode chamar
    unsafe extern "C++" {
        include!("meu_projeto/include/motor.h");

        type MotorFisica;
        fn criar_motor() -> UniquePtr<MotorFisica>;
        fn simular_passo(self: &MotorFisica, delta_tempo: f64);
    }

    // Funções Rust que C++ pode chamar
    extern "Rust" {
        fn calcular_colisao(x: f64, y: f64, raio: f64) -> bool;
    }
}

fn calcular_colisao(x: f64, y: f64, raio: f64) -> bool {
    (x * x + y * y).sqrt() < raio
}