题解 | #【模板】栈#

use std::io::{self, *};
use std::result::Result;

struct Stack {
    s: [i32; 100_010],
    tt: usize,
}

impl Stack {
    fn new() -> Stack {
        Stack {
            s: [0; 100_010],
            tt: usize::MAX,
        }
    }

    fn push(&mut self, x: i32) {
        self.tt += 1;
        self.s[self.tt] = x;
    }

    fn pop(&mut self) -> Result<(), &'static str> {
        if self.tt != usize::MAX {
            println!("{}", self.s[self.tt]);
            self.tt -= 1;
            Ok(())
        } else {
            Err("error")
        }
    }

    fn top(&self) -> Result<(), &'static str> {
        if self.tt != usize::MAX {
            println!("{}", self.s[self.tt]);
            Ok(())
        } else {
            Err("error")
        }
    }
}

fn main() {
    let mut s = Stack::new();
    let stdin = io::stdin();
    let mut lines = stdin.lock().lines().map(|l| {
        l.unwrap()
    });

    if let Ok(n) = lines.next().unwrap().parse::<usize>() {
        for _ in 0..n {
            let line = lines.next().unwrap();
            let tokens: Vec<&str> = line.split_whitespace().collect();

            if let Some(op) = tokens.get(0) {
                match *op {
                    "push" => {
                        if let Ok(x) = tokens[1].parse::<i32>() {
                            s.push(x);
                        }
                    }
                    "pop" => {
                        if let Err(err) = s.pop() {
                            println!("{}", err);
                        }
                    }
                    "top" => {
                        if let Err(err) = s.top() {
                            println!("{}", err);
                        }
                    }
                    _ => (),
                }
            }
        }
    }
}