Rust循环队列代码

#[no_std]
struct CycleQueue {
    data: Vec<i32>,
    head: usize,
    tail: usize,
    size: usize,
}

impl CycleQueue {
    fn new(size: usize) -> Self {
        CycleQueue {
            data: vec![0; size],
            head: 0,
            tail: 0,
            size,
        }
    }
    fn is_empty(&self) -> bool {
        self.head == self.tail
    }
    fn is_full(&self) -> bool {
        (self.tail + 1) % self.size == self.head
    }
    fn enqueue(&mut self, data: i32) -> bool {
        if self.is_full() {
            println!("queue is full");
            return false;
        }
        self.data[self.tail] = data;
        self.tail = (self.tail + 1) % self.size;
        true
    }
    fn dequeue(&mut self) -> Option<i32> {
        if self.is_empty() {
            println!("queue is empty");
            return None;
        }
        let ret = self.data[self.head];
        self.head = (self.head + 1) % self.size;
        Some(ret)
    }
    fn show(&self) {
        println!("head: {}, tail: {}", self.head, self.tail);
        for i in 0..self.size {
            print!("{} ", self.data[i]);
        }
        println!();
    }
    fn size(&self) -> usize {
        (self.tail + self.size - self.head) % self.size 
    }
}

fn main() {
    let mut c = CycleQueue::new(10);
    println!("{}", c.is_empty());
    println!("{}", c.is_full());
    c.show();
    c.enqueue(100);
    c.show();
    println!("{}", c.is_empty());
    c.dequeue();
    c.show();
    println!("{}", c.is_empty());
    for i in 0..9 {
        c.enqueue(i);
    }
    println!("{}", c.is_full());
    c.show();
    c.enqueue(100);  // fail
    c.show();
}