Sure, here's an equivalent code in Rust:
```
fn print_int_or_char(input_string: &str, index: usize) {
    if let Some(c) = input_string.chars().nth(index) {
        if c.is_digit(10) {
            let num = c.to_digit(10).unwrap();
            println!("Integer: {}", num);
        } else if c.is_ascii_alphabetic() {
            println!("Character: {}", c);
        } else {
            println!("Invalid input");
        }
    } else {
        println!("Index out of bounds");
    }
}

fn main() {
    let input_string = "a1b2c3";
    let index = 2;

    print_int_or_char(input_string, index);
}
```
In Rust, we use references (&) instead of pointers to pass data around. The &str type is a reference to a string slice, which is similar to a C string.

The print_int_or_char function takes a reference to a string slice and an index as its arguments. We use the chars method on the input string to iterate over its characters, and use the nth method to get the character at the specified index. If the index is out of bounds, we print an error message.

We then use the is_digit method on the character to check if it's a digit, and the to_digit method to convert the digit character to an integer value. If the character is a letter, we print it directly. If the input is neither a digit nor a letter, we print an "Invalid input" message.

Note that Rust has a strong type system that helps prevent memory errors and other bugs that can arise from working with pointers in C. Therefore, while pointers are still used in Rust, they are less common than in C, and Rust code often relies on references and safe borrowing rules to manage memory.
แน่นอนว่า นี่คือโค้ดที่เทียบเท่ากันใน Rust: ``` fn print_int_or_char(input_string: &str, index: usize) { if la Some(c) = input_string.chars().nth(index) { if c.is_digit(10) { ให้ num = c.to_digit(10).unwrap(); println!("จำนวนเต็ม: {}", num); } อื่น ๆ ถ้า c.is_ascii_letteric() { println!("อักขระ: {}", c); } else { println!("อินพุตไม่ถูกต้อง"); } } else { println!("ดัชนีอยู่นอกขอบเขต"); } } fn main() { ให้ input_string = "a1b2c3"; ให้ดัชนี = 2; print_int_or_char (input_string, ดัชนี); } ``` ใน Rust เราใช้การอ้างอิง (&) แทนตัวชี้ในการส่งข้อมูล ประเภท &str คือการอ้างอิงถึงส่วนสตริง ซึ่งคล้ายกับสตริง C ฟังก์ชัน print_int_or_char ใช้การอ้างอิงถึงส่วนสตริงและดัชนีเป็นอาร์กิวเมนต์ เราใช้วิธี chars บนสตริงอินพุตเพื่อวนซ้ำอักขระ และใช้วิธีที่ n เพื่อรับอักขระที่ดัชนีที่ระบุ หากดัชนีอยู่นอกขอบเขต เราจะพิมพ์ข้อความแสดงข้อผิดพลาด จากนั้นเราใช้วิธี is_digit กับอักขระเพื่อตรวจสอบว่าเป็นตัวเลขหรือไม่ และใช้วิธี to_digit เพื่อแปลงอักขระหลักให้เป็นค่าจำนวนเต็ม หากอักขระเป็นตัวอักษรเราจะพิมพ์โดยตรง หากอินพุตไม่ใช่ทั้งตัวเลขหรือตัวอักษร เราจะพิมพ์ข้อความ "อินพุตไม่ถูกต้อง" โปรดทราบว่า Rust มีระบบประเภทที่แข็งแกร่งซึ่งช่วยป้องกันข้อผิดพลาดของหน่วยความจำและข้อบกพร่องอื่น ๆ ที่อาจเกิดขึ้นจากการทำงานกับพอยน์เตอร์ใน C ดังนั้นในขณะที่พอยน์เตอร์ยังคงใช้ใน Rust แต่ก็พบได้น้อยกว่าใน C และโค้ดของสนิมมักจะอาศัย การอ้างอิงและกฎการยืมอย่างปลอดภัยเพื่อจัดการหน่วยความจำ
spam fails_task lang_mismatch pii not_appropriate hate_speech sexual_content quality toxicity humor helpfulness creativity violence