Learn Rust Coding · Lección

Interacción con Rust no seguro

Comprenda cuándo y cómo utilizar bloques `unsafe` para omitir las comprobaciones de seguridad de Rust y habilitar FFI y operaciones de bajo nivel con la memoria.

Interacción con Rust no seguro es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 3 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 3 lecciones en total.

Rust no seguro: introducción

¡Le damos la bienvenida a Rust no seguro! Aunque Rust es conocido por sus garantías de seguridad de memoria, hay situaciones específicas en las que puede necesitar omitir algunas de estas comprobaciones.

La palabra clave unsafe de Rust le permite hacerlo. No es una forma de escribir código «malo», sino una herramienta para casos de uso avanzados en los que necesita un control más directo sobre la memoria o el hardware.

Los cinco superpoderes de unsafe

Cuando utiliza un bloque unsafe, obtiene acceso a cinco acciones especiales que el compilador de Rust normalmente impide:

Desreferenciar punteros sin formato: Acceder directamente a direcciones de memoria.
Llamar a funciones o métodos unsafe: Ejecutar funciones con precondiciones que el compilador no puede verificar.
Implementar traits unsafe: Declarar que su tipo mantiene invariantes específicos.
Acceder a variables estáticas mutables o modificarlas: Compartir estado mutable de forma global, con el riesgo de provocar condiciones de carrera.
Acceder a campos de union: Leer una unión, cuyo tipo podría no ser válido para los datos actuales.

Desreferenciar punteros sin formato

Los punteros sin formato son direcciones de memoria que no cuentan con las garantías de seguridad habituales de Rust. Puede crearlos a partir de referencias (&T, &mut T), pero desreferenciarlos requiere un bloque unsafe.

Esto significa que usted, como programador, es responsable de garantizar que el puntero sea válido y apunte a memoria asignada.

fn main() {
  let mut num = 5;
  let r1 = &num as *const i32; // Immutable raw pointer
  let r2 = &mut num as *mut i32; // Mutable raw pointer

  unsafe { // The `unsafe` block starts here
    println!("r1 points to: {}", *r1);
    *r2 = 10; // Modify data through mutable raw pointer
    println!("r2 points to: {}", *r2);
  } // The `unsafe` block ends here

  println!("Num is now: {}", num);
}

Llamar a funciones no seguras

Algunas funciones están marcadas como unsafe fn. Esto significa que la función tiene precondiciones que el compilador de Rust no puede garantizar. Por ejemplo, una función podría esperar una dirección de memoria válida, pero no puede verificarla.

Las llamadas a estas funciones deben envolverse en un bloque unsafe, lo que indica que usted, como quien realiza la llamada, garantiza que se cumplen todas las precondiciones.

unsafe fn dangerous_operation() {
  println!("This operation could be dangerous if preconditions aren't met!");
}

fn main() {
  println!("Attempting a dangerous operation...");
  unsafe { // Calling an unsafe function requires `unsafe`
    dangerous_operation();
  }
  println!("Operation completed.");
}

Variables estáticas mutables

Rust impide de forma predeterminada el estado mutable global para evitar condiciones de carrera. Sin embargo, puede declarar variables estáticas mutables mediante static mut.

Acceder a estas variables o modificarlas se considera unsafe porque varios subprocesos podrían intentar acceder a ellas simultáneamente, lo que provocaría un comportamiento indefinido. La sincronización adecuada es responsabilidad suya.

static mut COUNTER: i32 = 0; // A mutable static variable

fn add_to_counter(inc: i32) {
  unsafe { // Modifying `static mut` requires `unsafe`
    COUNTER += inc;
  }
}

fn main() {
  add_to_counter(5);
  unsafe { // Reading `static mut` also requires `unsafe`
    println!("COUNTER after first add: {}", COUNTER);
  }

  add_to_counter(10);
  unsafe {
    println!("COUNTER after second add: {}", COUNTER);
  }
}

Implementar traits no seguros

Algunos traits de Rust están marcados como unsafe trait. Esto indica que, para implementarlos, es necesario mantener ciertos invariantes que el compilador no puede comprobar.

Un ejemplo habitual son los traits Send y Sync, relacionados con la seguridad de los subprocesos. Si implementa manualmente un unsafe trait, debe usar unsafe impl Trait for Type y garantizar sus propiedades de seguridad.

La mayoría de los principiantes se encontrarán con esto con menos frecuencia, ya que Rust suele gestionarlo automáticamente o mediante abstracciones seguras.

Acceder a campos de una unión

Una union es un tipo especial que puede contener el valor de *una* de sus variantes en un momento dado, pero todas las variantes comparten la misma ubicación de memoria. Es similar a las uniones de C.

Acceder a un campo de una union requiere un bloque unsafe porque el compilador no puede saber qué campo está activo en ese momento. Leer un campo inactivo puede provocar un comportamiento indefinido o una interpretación incorrecta de los datos.

union Data {
  integer: u32,
  float: f32,
}

fn main() {
  let mut d = Data { integer: 42 }; // Initialize with an integer

  unsafe {
    // Accessing 'integer' is safe here
    println!("Integer value: {}", d.integer);

    // Accessing 'float' is unsafe, as 'integer' was initialized.
    // This would interpret the integer's bits as a float.
    // println!("Float value (unsafe): {}", d.float);
  }

  d.float = 3.14; // Now initialize with a float
  unsafe {
    // Accessing 'float' is safe now
    println!("Float value: {}", d.float);
  }
}

Situaciones prácticas para usar unsafe

Aunque unsafe debe utilizarse con moderación, es fundamental para varias tareas de programación avanzada:

Interfaz de funciones foráneas (FFI): Interactuar con código escrito en otros lenguajes (como bibliotecas de C/C++).
Optimizaciones de rendimiento: En ocasiones, omitir las comprobaciones de Rust puede proporcionar pequeñas mejoras de rendimiento en secciones críticas (pero ¡mida primero!).
Programación de sistemas de bajo nivel: Escribir sistemas operativos, controladores de dispositivos o sistemas embebidos.
Crear abstracciones seguras: Implementar estructuras de datos o API seguras sobre primitivas no seguras (por ejemplo, cómo se construye Vec).

Su responsabilidad al usar unsafe

Cuando utiliza unsafe, asume la responsabilidad de mantener manualmente las garantías de seguridad de Rust. Esto implica:

Garantizar que la memoria sea válida y esté correctamente alineada.
Evitar condiciones de carrera al trabajar con estado mutable compartido.
Evitar punteros colgantes o errores de uso después de liberar la memoria.
Garantizar que se cumplan todas las precondiciones de las funciones.

El uso incorrecto de unsafe puede provocar un comportamiento indefinido, el peor tipo de error, que además puede ser muy difícil de depurar.

Comprobación de conocimientos sobre unsafe

¿Cuál de las siguientes acciones requiere un bloque unsafe en Rust?

Repaso: Rust no seguro

Ha aprendido sobre Rust no seguro, una potente función que permite omitir algunas comprobaciones de seguridad en tiempo de compilación de Rust para situaciones específicas y avanzadas.

Recuerde que unsafe no desactiva por completo el comprobador de préstamos, sino que transfiere completamente a usted, el programador, la responsabilidad de la seguridad de la memoria y de los invariantes. Úselo con criterio y extrema precaución, normalmente para FFI, optimizaciones de bajo nivel o la creación de abstracciones seguras.

Preguntas frecuentes

¿La lección «Interacción con Rust no seguro» es gratis?

Sí — el texto completo de «Interacción con Rust no seguro» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 3 lecciones en total.

¿Qué aprenderé en «Interacción con Rust no seguro»?

Comprenda cuándo y cómo utilizar bloques `unsafe` para omitir las comprobaciones de seguridad de Rust y habilitar FFI y operaciones de bajo nivel con la memoria. Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 3.

¿Cuánto tiempo toma la lección «Interacción con Rust no seguro»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Learn Rust Coding