El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Tipos de Datos

Siguiente ►
►

En Rust, los tipos de datos son fundamentales para escribir programas seguros y eficientes. Este tema cubre los tipos de datos básicos que Rust ofrece, cómo declararlos y usarlos, y algunos ejemplos prácticos para ilustrar su uso.

Tipos de Datos Primitivos

Rust tiene varios tipos de datos primitivos que se pueden dividir en las siguientes categorías:

  1. Escalares:

    • Enteros
    • Punto Flotante
    • Booleanos
    • Caracteres

  2. Compuestos:

    • Tuplas
    • Arrays

Enteros

Los enteros en Rust pueden ser con signo (i) o sin signo (u) y vienen en varios tamaños:

Tipo Tamaño Rango
i8 8 bits -128 a 127
i16 16 bits -32,768 a 32,767
i32 32 bits -2,147,483,648 a 2,147,483,647
i64 64 bits -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807
i128 128 bits -170,141,183,460,469,231,731,687,303,715,884,105,728 a 170,141,183,460,469,231,731,687,303,715,884,105,727
isize tamaño del puntero depende de la arquitectura
u8 8 bits 0 a 255
u16 16 bits 0 a 65,535
u32 32 bits 0 a 4,294,967,295
u64 64 bits 0 a 18,446,744,073,709,551,615
u128 128 bits 0 a 340,282,366,920,938,463,463,374,607,431,768,211,455
usize tamaño del puntero depende de la arquitectura

Ejemplo de uso de enteros:

fn main() {
    let x: i32 = 42; // Entero con signo de 32 bits
    let y: u8 = 255; // Entero sin signo de 8 bits
    println!("x: {}, y: {}", x, y);
}

Punto Flotante

Rust soporta dos tipos de números de punto flotante: f32 y f64.

Tipo Tamaño Precisión
f32 32 bits Precisión simple
f64 64 bits Precisión doble

Ejemplo de uso de punto flotante:

fn main() {
    let x: f32 = 3.14; // Número de punto flotante de 32 bits
    let y: f64 = 2.71828; // Número de punto flotante de 64 bits
    println!("x: {}, y: {}", x, y);
}

Booleanos

El tipo booleano en Rust se representa con bool y puede tener dos valores: true o false.

Ejemplo de uso de booleanos:

fn main() {
    let is_rust_fun: bool = true;
    println!("¿Es Rust divertido? {}", is_rust_fun);
}

Caracteres

El tipo char en Rust representa un carácter Unicode y ocupa 4 bytes.

Ejemplo de uso de caracteres:

fn main() {
    let letter: char = 'R';
    let emoji: char = '😊';
    println!("Letra: {}, Emoji: {}", letter, emoji);
}

Tipos de Datos Compuestos

Tuplas

Las tuplas pueden agrupar múltiples valores de diferentes tipos en una sola estructura.

Ejemplo de uso de tuplas:

fn main() {
    let tuple: (i32, f64, char) = (42, 3.14, 'R');
    let (x, y, z) = tuple; // Desestructuración de la tupla
    println!("x: {}, y: {}, z: {}", x, y, z);
}

Arrays

Los arrays en Rust tienen un tamaño fijo y todos sus elementos deben ser del mismo tipo.

Ejemplo de uso de arrays:

fn main() {
    let array: [i32; 3] = [1, 2, 3];
    println!("Primer elemento: {}", array[0]);
}

Ejercicios Prácticos

Ejercicio 1: Declaración y Uso de Variables

  1. Declara una variable entera a de tipo i32 y asígnale el valor 10.
  2. Declara una variable de punto flotante b de tipo f64 y asígnale el valor 20.5.
  3. Declara una variable booleana c y asígnale el valor true.
  4. Declara una variable de carácter d y asígnale el valor 'Z'.
  5. Imprime todas las variables.

Solución:

fn main() {
    let a: i32 = 10;
    let b: f64 = 20.5;
    let c: bool = true;
    let d: char = 'Z';
    println!("a: {}, b: {}, c: {}, d: {}", a, b, c, d);
}

Ejercicio 2: Uso de Tuplas y Arrays

  1. Declara una tupla my_tuple que contenga un entero 5, un punto flotante 3.14 y un carácter 'A'.
  2. Desestructura la tupla en tres variables y luego imprímelas.
  3. Declara un array my_array de tipo i32 con los valores [10, 20, 30, 40, 50].
  4. Imprime el tercer elemento del array.

Solución:

fn main() {
    let my_tuple: (i32, f64, char) = (5, 3.14, 'A');
    let (x, y, z) = my_tuple;
    println!("x: {}, y: {}, z: {}", x, y, z);

    let my_array: [i32; 5] = [10, 20, 30, 40, 50];
    println!("Tercer elemento: {}", my_array[2]);
}

Conclusión

En esta sección, hemos cubierto los tipos de datos básicos en Rust, incluyendo enteros, punto flotante, booleanos, caracteres, tuplas y arrays. Estos tipos de datos son fundamentales para cualquier programa en Rust y proporcionan una base sólida para construir aplicaciones más complejas. En el próximo tema, exploraremos las funciones en Rust, que nos permitirán organizar y reutilizar el código de manera eficiente.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados