Wie kann ich einen stapelzugeordneten vektorähnlichen Container erstellen?

Wie würden Sie vorgehen, um einen stapelzugeordneten vektorähnlichen Container mit einer festen Obergrenze für die Anzahl der Elemente zu erstellen, die er enthalten kann? Du kannst meinen Versuch hierunter sehen, aber er wird nicht kompiliert:

// The following is at crate level
#![feature(unsafe_destructor)]

use std::mem;
use std::ptr;
use std::slice::Iter;

pub struct StackVec<T> {
    buf: [T; 10],
    len: usize,
}

impl<T> StackVec<T> {
    pub fn new() -> StackVec<T> {
        StackVec {
            buf: unsafe { mem::uninitialized() },
            len: 0,
        }
    }

    pub fn iter(&self) -> Iter<T> {
        (&self.buf[..self.len]).iter()
    }

    pub fn push(&mut self, value: T) {
        unsafe { ptr::write(self.buf.get_mut(self.len).unwrap(), value); }
        self.len += 1;
    }

    pub fn pop(&mut self) -> Option<T> {
        if self.len == 0 {
            None
        } else {
            unsafe {
                self.len -= 1;
                Some(ptr::read(self.buf.get(self.len).unwrap()))
            }
        }
    }
}

#[unsafe_destructor]
impl<T> Drop for StackVec<T>
    where T: Drop
{
    fn drop(&mut self) {
        for elem in self.iter() {
            unsafe { ptr::read(elem); }
        }
        unsafe { mem::forget(self.buf); } // ERROR: [1]
    }
}

Dies ist der Kompilierungsfehler, den ich erhalte:
[1] Fehler: Typ @ kann nicht verlassen werdstackvec::StackVec<T>, das das @ definieDrop trait

Antworten auf die Frage(4)

Ihre Antwort auf die Frage