C++中stack与queue的实现原理与应用场景

1. 理解stack与queue的本质特性

在C++标准库中，stack和queue作为容器适配器（Container Adapters）存在，它们基于底层容器实现特定的数据操作规则。理解这一点至关重要——它们不是独立的容器，而是对现有容器接口的再封装。

stack遵循LIFO（Last In First Out）原则，就像餐厅里叠放的餐盘，你只能从最顶部取放。这种特性使其特别适合需要"回退"机制的场景，比如：

• 函数调用栈（call stack）
• 表达式求值
• 撤销操作(Undo)实现

queue则遵循FIFO（First In First Out）原则，如同排队买票的队伍，先来的人先获得服务。典型应用包括：

• 消息队列处理
• 打印机任务调度
• 广度优先搜索(BFS)算法

关键区别：stack只允许在一端操作，而queue允许在两端分别进行插入和删除，但两者都不支持随机访问。

2. 标准库实现深度解析

2.1 默认底层容器选择

stack和queue默认使用deque作为底层容器，这是经过精心设计的：

cpp复制template <class T, class Container = deque<T>> 
class stack;

template <class T, class Container = deque<T>>  
class queue;

选择deque的原因在于：

1. 内存效率：deque结合了vector和list的优点，支持快速的首尾操作
2. 性能平衡：不需要像vector那样频繁扩容，也不像list那样内存碎片化
3. 缓存友好：数据块连续存储，提高缓存命中率

2.2 关键API对比

stack核心接口：

cpp复制push()  // 入栈 - O(1)
pop()   // 出栈 - O(1) 
top()   // 查看栈顶 - O(1)
empty() // 判空 - O(1)
size()  // 元素数量 - O(1)

queue核心接口：

cpp复制push()  // 入队 - O(1)
pop()   // 出队 - O(1) 
front() // 队首元素 - O(1)
back()  // 队尾元素 - O(1) 
empty() // 判空 - O(1)
size()  // 元素数量 - O(1)

性能提示：所有操作的时间复杂度都是常数级，这是选择它们而非其他容器的重要原因。

3. 自定义底层容器的实践

虽然默认使用deque，但我们可以根据场景替换底层容器：

3.1 使用vector实现stack

cpp复制stack<int, vector<int>> vec_stack;

优势：

• 内存完全连续，遍历更快
• 适合元素数量固定或增长缓慢的场景

风险：

• 扩容时可能抛出bad_alloc异常
• 频繁push/pop会导致反复扩容缩容

3.2 使用list实现queue

cpp复制queue<string, list<string>> lst_queue;

优势：

• 永远不会重新分配内存
• 插入删除绝对O(1)

劣势：

• 内存不连续，缓存不友好
• 每个元素需要额外存储前后指针

3.3 性能实测对比

通过百万次操作测试（单位：ms）：

数据说明：

1. vector在stack场景表现接近deque
2. list因指针操作开销明显落后
3. vector不能用于queue（无pop_front）

4. 模板进阶技巧剖析

4.1 模板参数推导机制

现代C++增强了模板类型推导能力：

cpp复制template <typename T>
void printStack(stack<T> s) {
    while(!s.empty()) {
        cout << s.top() << " ";
        s.pop();
    }
}

// 调用时自动推导T为int
stack<int> s;
printStack(s);  

4.2 可变参数模板应用

结合可变参数模板实现栈的批量初始化：

cpp复制template <typename T>
void pushAll(stack<T>& s) {}

template <typename T, typename... Args>
void pushAll(stack<T>& s, T first, Args... args) {
    s.push(first);
    pushAll(s, args...);
}

// 使用示例
stack<int> s;
pushAll(s, 1, 2, 3, 4, 5);

4.3 模板特化实践

针对特定类型优化stack行为：

cpp复制template <>
class stack<bool> {
private:
    vector<unsigned char> data; // 按位存储
public:
    void push(bool val) {
        // 特殊位操作实现
    }
    // ...其他成员函数
};

5. 典型应用场景实现

5.1 括号匹配校验器

利用stack实现高效的括号匹配检测：

cpp复制bool isValidParentheses(const string& s) {
    stack<char> stk;
    for(char c : s) {
        if(c == '(' || c == '[' || c == '{') {
            stk.push(c);
        } else {
            if(stk.empty()) return false;
            char top = stk.top();
            if((c == ')' && top != '(') ||
               (c == ']' && top != '[') ||
               (c == '}' && top != '{')) {
                return false;
            }
            stk.pop();
        }
    }
    return stk.empty();
}

5.2 线程安全队列实现

结合mutex实现生产者-消费者队列：

cpp复制template <typename T>
class ConcurrentQueue {
private:
    queue<T> q;
    mutex mtx;
    condition_variable cv;
public:
    void push(T item) {
        lock_guard<mutex> lock(mtx);
        q.push(move(item));
        cv.notify_one();
    }
    
    bool try_pop(T& item) {
        lock_guard<mutex> lock(mtx);
        if(q.empty()) return false;
        item = move(q.front());
        q.pop();
        return true;
    }
    
    void wait_pop(T& item) {
        unique_lock<mutex> lock(mtx);
        cv.wait(lock, [this]{ return !q.empty(); });
        item = move(q.front());
        q.pop();
    }
};

6. 性能优化与陷阱规避

6.1 避免不必要的拷贝

使用emplace替代push：

cpp复制stack<pair<int, string>> s;
s.push(make_pair(1, "test"));  // 需要构造临时对象
s.emplace(1, "test");          // 直接在栈内构造

6.2 迭代器失效问题

容器适配器不提供迭代器是有原因的——底层容器的迭代器可能在操作后失效。如果需要遍历，应该：

1. 创建副本进行操作
2. 使用临时容器存储数据

错误示例：

cpp复制deque<int> dq = {1,2,3};
stack<int> s(dq);
// 获取底层容器引用（危险！）
deque<int>& ref = s.*(&stack<int>::c); 
ref.push_back(4); // 可能导致stack状态不一致

6.3 异常安全保证

标准库实现提供了三种异常保证级别：

1. push操作：强异常保证（操作失败则状态不变）
2. pop操作：不抛出异常（noexcept）
3. top/front/back：强异常保证

自定义实现时应保持相同标准：

cpp复制template <typename T>
class SafeStack {
    vector<T> data;
public:
    void push(const T& item) {
        data.push_back(item); // 利用vector的强异常保证
    }
    
    void pop() noexcept {
        if(!data.empty()) {
            data.pop_back();
        }
    }
    
    T& top() {
        if(data.empty()) throw out_of_range("Stack is empty");
        return data.back();
    }
};

7. C++17/20新特性集成

7.1 结构化绑定应用

方便地处理stack顶部的多个值：

cpp复制stack<pair<int, string>> s;
s.emplace(1, "hello");

auto [id, msg] = s.top();  // C++17结构化绑定
cout << id << ":" << msg;

7.2 概念约束模板（C++20）

使用concepts约束模板参数：

cpp复制template <typename C>
concept StackContainer = requires(C c) {
    { c.back() } -> same_as<typename C::value_type&>;
    { c.push_back(typename C::value_type{}) };
    { c.pop_back() };
};

template <typename T, StackContainer Container = deque<T>>
class SafeStack {
    // 实现...
};

7.3 三路比较运算符

简化元素比较逻辑：

cpp复制template <typename T>
bool compareStacks(stack<T>& a, stack<T>& b) {
    if(a.size() != b.size()) return false;
    
    stack<T> tmpA = a, tmpB = b;
    while(!tmpA.empty()) {
        if((tmpA.top() <=> tmpB.top()) != 0) {
            return false;
        }
        tmpA.pop();
        tmpB.pop();
    }
    return true;
}

8. 设计模式中的应用

8.1 命令模式实现

利用stack实现命令的撤销/重做：

cpp复制class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
    virtual void undo() = 0;
};

class CommandManager {
    stack<unique_ptr<Command>> undoStack;
    stack<unique_ptr<Command>> redoStack;
public:
    void executeCommand(unique_ptr<Command> cmd) {
        cmd->execute();
        undoStack.push(move(cmd));
        // 执行新命令后清空redo栈
        while(!redoStack.empty()) redoStack.pop(); 
    }
    
    void undo() {
        if(undoStack.empty()) return;
        auto cmd = move(undoStack.top());
        undoStack.pop();
        cmd->undo();
        redoStack.push(move(cmd));
    }
    
    void redo() {
        if(redoStack.empty()) return;
        auto cmd = move(redoStack.top());
        redoStack.pop();
        cmd->execute();
        undoStack.push(move(cmd));
    }
};

8.2 状态模式管理

用stack管理复杂状态流转：

cpp复制class GameState {
public:
    virtual ~GameState() = default;
    virtual void handleInput() = 0;
    virtual void update() = 0;
    virtual void render() = 0;
};

class GameStateStack {
    stack<unique_ptr<GameState>> states;
public:
    void pushState(unique_ptr<GameState> state) {
        if(!states.empty()) {
            states.top()->pause();
        }
        states.push(move(state));
        states.top()->enter();
    }
    
    void popState() {
        if(!states.empty()) {
            states.top()->exit();
            states.pop();
        }
        if(!states.empty()) {
            states.top()->resume();
        }
    }
    
    void changeState(unique_ptr<GameState> state) {
        popState();
        pushState(move(state));
    }
    
    GameState* getCurrentState() const {
        return states.empty() ? nullptr : states.top().get();
    }
};

9. 跨平台开发注意事项

9.1 内存对齐问题

不同平台对底层容器的内存处理可能有差异：

cpp复制template <typename T>
class AlignedStack {
    stack<T> data;
#if defined(_MSC_VER)
    __declspec(align(64)) // Windows特定对齐
#else
    alignas(64)           // 通用对齐
#endif
    char cachePad[64];    // 避免false sharing
};

9.2 字节序处理

网络传输时需要处理字节序：

cpp复制template <typename T>
void serializeStack(stack<T>& s, ostream& os) {
    stack<T> temp;
    size_t size = s.size();
    os.write(reinterpret_cast<char*>(&size), sizeof(size));
    
    while(!s.empty()) {
        temp.push(s.top());
        s.pop();
    }
    
    while(!temp.empty()) {
        T val = temp.top();
        // 转换为网络字节序
        if constexpr(sizeof(T) == 4) {
            val = htonl(val);
        }
        os.write(reinterpret_cast<char*>(&val), sizeof(T));
        s.push(temp.top());
        temp.pop();
    }
}

10. 测试与调试技巧

10.1 自定义断言宏

为stack操作添加调试信息：

cpp复制#define CHECK_STACK(stack) \
    do { \
        if((stack).empty()) { \
            cerr << "Stack empty at " << __FILE__ << ":" << __LINE__ << endl; \
            assert(false); \
        } \
    } while(0)

void safeStackTop(stack<int>& s) {
    CHECK_STACK(s);
    cout << "Top element: " << s.top() << endl;
}

10.2 内存泄漏检测

使用自定义分配器跟踪内存：

cpp复制template <typename T>
class TrackingAllocator {
    static size_t totalAllocated;
public:
    using value_type = T;
    
    T* allocate(size_t n) {
        totalAllocated += n * sizeof(T);
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }
    
    void deallocate(T* p, size_t n) {
        totalAllocated -= n * sizeof(T);
        ::operator delete(p);
    }
    
    static size_t currentUsage() { return totalAllocated; }
};

template <typename T>
size_t TrackingAllocator<T>::totalAllocated = 0;

// 使用示例
using TrackedStack = stack<int, deque<int, TrackingAllocator<int>>>;

11. 现代C++最佳实践

11.1 使用noexcept优化

标记不会抛出异常的操作：

cpp复制template <typename T>
class OptimizedStack {
    vector<T> data;
public:
    void pop() noexcept {
        data.pop_back();
    }
    
    bool empty() const noexcept {
        return data.empty();
    }
    
    size_t size() const noexcept {
        return data.size();
    }
};

11.2 移动语义支持

优化临时对象处理：

cpp复制template <typename T>
class MovableStack {
    deque<T> data;
public:
    void push(const T& item) {
        data.push_back(item);
    }
    
    void push(T&& item) {
        data.push_back(move(item));
    }
    
    T pop() {
        T val = move(data.back());
        data.pop_back();
        return val;
    }
};

11.3 constexpr支持

编译期栈操作（C++20）：

cpp复制template <typename T, size_t N>
class ConstexprStack {
    array<T, N> data;
    size_t top = 0;
public:
    constexpr void push(const T& item) {
        data[top++] = item;
    }
    
    constexpr T pop() {
        return data[--top];
    }
    
    constexpr bool empty() const {
        return top == 0;
    }
};

// 编译期计算斐波那契数列
constexpr int fib(int n) {
    ConstexprStack<int, 100> s;
    s.push(0);
    s.push(1);
    
    for(int i = 2; i <= n; ++i) {
        int a = s.pop();
        int b = s.pop();
        s.push(a);
        s.push(a + b);
    }
    
    return s.pop();
}

static_assert(fib(10) == 55);

12. 性能关键场景优化

12.1 内存预分配

减少动态扩容开销：

cpp复制template <typename T>
class PreallocatedStack {
    vector<T> data;
public:
    explicit PreallocatedStack(size_t capacity) {
        data.reserve(capacity);
    }
    
    void push(const T& item) {
        if(data.size() == data.capacity()) {
            // 自定义扩容策略
            size_t newCapacity = data.capacity() * 2;
            vector<T> newData;
            newData.reserve(newCapacity);
            move(data.begin(), data.end(), back_inserter(newData));
            data.swap(newData);
        }
        data.push_back(item);
    }
};

12.2 无锁栈实现

适用于高并发场景：

cpp复制template <typename T>
class LockFreeStack {
private:
    struct Node {
        T data;
        Node* next;
    };
    
    atomic<Node*> head = nullptr;
    
public:
    void push(const T& item) {
        Node* newNode = new Node{item, head.load()};
        while(!head.compare_exchange_weak(newNode->next, newNode)) {
            // CAS失败重试
        }
    }
    
    bool pop(T& result) {
        Node* oldHead = head.load();
        while(oldHead && 
              !head.compare_exchange_weak(oldHead, oldHead->next)) {
            // CAS失败重试
        }
        if(!oldHead) return false;
        result = move(oldHead->data);
        delete oldHead;
        return true;
    }
};

13. 模板元编程应用

13.1 类型安全的栈操作

使用SFINAE限制栈操作：

cpp复制template <typename Stack, typename = void>
struct is_stack : false_type {};

template <typename Stack>
struct is_stack<Stack, void_t<
    decltype(declval<Stack>().push(declval<typename Stack::value_type>())),
    decltype(declval<Stack>().pop()),
    decltype(declval<Stack>().top())
>> : true_type {};

template <typename Stack>
enable_if_t<is_stack<Stack>::value>
clearStack(Stack& s) {
    while(!s.empty()) s.pop();
}

13.2 编译期栈检查

静态断言确保类型安全：

cpp复制template <typename Stack, typename T>
void pushChecked(Stack& s, const T& item) {
    static_assert(
        is_same_v<typename Stack::value_type, T>,
        "Type mismatch between stack and pushed item"
    );
    s.push(item);
}

14. 实际工程案例

14.1 表达式求值器

支持四则运算和函数调用：

cpp复制double evaluateExpression(const string& expr) {
    stack<double> values;
    stack<char> ops;
    
    auto applyOp = [&](char op) {
        double b = values.top(); values.pop();
        double a = values.top(); values.pop();
        switch(op) {
            case '+': values.push(a + b); break;
            case '-': values.push(a - b); break;
            case '*': values.push(a * b); break;
            case '/': 
                if(b == 0) throw runtime_error("Division by zero");
                values.push(a / b); 
                break;
        }
    };
    
    for(size_t i = 0; i < expr.size(); ++i) {
        if(isspace(expr[i])) continue;
        
        if(expr[i] == '(') {
            ops.push(expr[i]);
        } else if(isdigit(expr[i]) || expr[i] == '.') {
            size_t end;
            double val = stod(expr.substr(i), &end);
            values.push(val);
            i += end - 1;
        } else if(expr[i] == ')') {
            while(!ops.empty() && ops.top() != '(') {
                applyOp(ops.top());
                ops.pop();
            }
            ops.pop(); // 弹出'('
        } else {
            while(!ops.empty() && 
                  ((ops.top() == '*' || ops.top() == '/') || 
                   ((ops.top() == '+' || ops.top() == '-') && 
                    (expr[i] == '+' || expr[i] == '-')))) {
                applyOp(ops.top());
                ops.pop();
            }
            ops.push(expr[i]);
        }
    }
    
    while(!ops.empty()) {
        applyOp(ops.top());
        ops.pop();
    }
    
    return values.top();
}

14.2 浏览器历史管理

模拟前进后退功能：

cpp复制class BrowserHistory {
    stack<string> backStack;
    stack<string> forwardStack;
    string current;
public:
    explicit BrowserHistory(string homepage) : current(move(homepage)) {}
    
    void visit(string url) {
        backStack.push(move(current));
        current = move(url);
        // 访问新页面时清空前进栈
        while(!forwardStack.empty()) forwardStack.pop();
    }
    
    string back(int steps) {
        while(steps-- > 0 && !backStack.empty()) {
            forwardStack.push(current);
            current = backStack.top();
            backStack.pop();
        }
        return current;
    }
    
    string forward(int steps) {
        while(steps-- > 0 && !forwardStack.empty()) {
            backStack.push(current);
            current = forwardStack.top();
            forwardStack.pop();
        }
        return current;
    }
};

15. 高级调试技巧

15.1 栈内容可视化

开发调试工具时很有用：

cpp复制template <typename T>
void visualizeStack(const stack<T>& s) {
    stack<T> temp = s;
    cout << "┌───────┐" << endl;
    while(!temp.empty()) {
        cout << "│ " << setw(5) << temp.top() << " │" << endl;
        temp.pop();
        if(!temp.empty()) {
            cout << "├───────┤" << endl;
        }
    }
    cout << "└───────┘" << endl;
}

// 使用示例
stack<int> s;
for(int i = 1; i <= 5; ++i) s.push(i);
visualizeStack(s);

15.2 内存布局分析

理解底层容器内存分布：

cpp复制template <typename Stack>
void analyzeMemoryLayout(const Stack& s) {
    cout << "Stack object size: " << sizeof(s) << " bytes\n";
    
    // 通过指针运算查看内存（仅用于调试）
    const auto* ptr = reinterpret_cast<const unsigned char*>(&s);
    cout << "First 16 bytes: ";
    for(size_t i = 0; i < 16 && i < sizeof(s); ++i) {
        printf("%02x ", ptr[i]);
    }
    cout << endl;
    
    // 输出典型实现的内存布局
    cout << "Typical stack memory layout:\n";
    cout << "+----------------+\n";
    cout << "| vtable pointer | (if polymorphic)\n";
    cout << "+----------------+\n";
    cout << "| Container data | (usually 3 pointers for deque)\n";
    cout << "+----------------+\n";
}

16. 跨语言互操作

16.1 C接口导出

供其他语言调用：

cpp复制extern "C" {
    struct CStack {
        void* handle;
    };
    
    CStack* stack_create() {
        try {
            auto* s = new stack<int>;
            return reinterpret_cast<CStack*>(s);
        } catch(...) {
            return nullptr;
        }
    }
    
    void stack_push(CStack* s, int val) {
        if(s) {
            reinterpret_cast<stack<int>*>(s->handle)->push(val);
        }
    }
    
    int stack_pop(CStack* s) {
        if(!s || reinterpret_cast<stack<int>*>(s->handle)->empty()) {
            return 0;
        }
        int val = reinterpret_cast<stack<int>*>(s->handle)->top();
        reinterpret_cast<stack<int>*>(s->handle)->pop();
        return val;
    }
    
    void stack_destroy(CStack* s) {
        if(s) {
            delete reinterpret_cast<stack<int>*>(s->handle);
            s->handle = nullptr;
        }
    }
}

16.2 Python绑定

使用pybind11创建Python扩展：

cpp复制#include <pybind11/pybind11.h>
#include <stack>

namespace py = pybind11;

class PyStack {
    std::stack<int> data;
public:
    void push(int val) { data.push(val); }
    int pop() { 
        if(data.empty()) throw std::runtime_error("Empty stack");
        int val = data.top();
        data.pop();
        return val;
    }
    bool empty() const { return data.empty(); }
    size_t size() const { return data.size(); }
};

PYBIND11_MODULE(stack_ext, m) {
    py::class_<PyStack>(m, "Stack")
        .def(py::init<>())
        .def("push", &PyStack::push)
        .def("pop", &PyStack::pop)
        .def("empty", &PyStack::empty)
        .def("__len__", &PyStack::size);
}

17. 设计扩展栈结构

17.1 支持O(1)获取最小值的栈

cpp复制template <typename T>
class MinStack {
    stack<T> data;
    stack<T> minStack;
public:
    void push(const T& val) {
        data.push(val);
        if(minStack.empty() || val <= minStack.top()) {
            minStack.push(val);
        }
    }
    
    void pop() {
        if(data.top() == minStack.top()) {
            minStack.pop();
        }
        data.pop();
    }
    
    T top() const { return data.top(); }
    T getMin() const { return minStack.top(); }
};

17.2 支持迭代的栈

突破标准栈的限制：

cpp复制template <typename T, typename Container = deque<T>>
class IterableStack : public stack<T, Container> {
public:
    using iterator = typename Container::iterator;
    using const_iterator = typename Container::const_iterator;
    
    iterator begin() { return this->c.begin(); }
    iterator end() { return this->c.end(); }
    const_iterator begin() const { return this->c.begin(); }
    const_iterator end() const { return this->c.end(); }
    const_iterator cbegin() const { return this->c.cbegin(); }
    const_iterator cend() const { return this->c.cend(); }
};

// 使用示例
IterableStack<int> s;
for(int i = 0; i < 5; ++i) s.push(i);
for(auto it = s.begin(); it != s.end(); ++it) {
    cout << *it << " ";
}

18. 性能基准测试

18.1 不同实现对比

测试百万次push/pop操作（单位：ms）：

18.2 内存占用分析

存储100万个int时的内存使用：

19. 异常处理策略

19.1 安全弹出模板

处理可能失败的pop操作：

cpp复制template <typename Stack, typename T>
bool safePop(Stack& s, T& out) {
    try {
        if(s.empty()) return false;
        out = s.top();
        s.pop();
        return true;
    } catch(const exception& e) {
        cerr << "Pop failed: " << e.what() << endl;
        return false;
    } catch(...) {
        cerr << "Unknown error during pop" << endl;
        return false;
    }
}

19.2 事务性操作

实现原子性的多栈操作：

cpp复制template <typename... Stacks>
bool transactionalPop(Stacks&... stacks) {
    tuple<decltype(stacks.top())...> items;
    
    try {
        // 尝试获取所有栈顶
        ((get<Stacks>(items) = stacks.top()), ...);
    } catch(...) {
        return false; // 任何一个栈为空则失败
    }
    
    try {
        // 全部成功才真正pop
        (stacks.pop(), ...);
        return true;
    } catch(...) {
        // 回滚：将取出的元素重新压栈
        int dummy[] = {0, (stacks.push(get<Stacks>(items)), 0)...};
        (void)dummy;
        return false;
    }
}

20. 未来演进方向

20.1 协程集成

C++20协程友好的栈实现：

cpp复制template <typename T>
struct StackPromise {
    stack<T> values;
    
    auto yield_value(T value) {
        values.push(value);
        return suspend_always{};
    }
    
    void return_void() {}
    stack<T> get_return_object() { return move(values); }
    suspend_never initial_suspend() { return {}; }
    suspend_never final_suspend() noexcept { return {}; }
    void unhandled_exception() { terminate(); }
};

template <typename T>
struct StackAwaitable {
    stack<T>& s;
    bool await_ready() { return !s.empty(); }
    void await_suspend(coroutine_handle<>) {}
    T await_resume() {
        T val = s.top();
        s.pop();
        return val;
    }
};

template <typename T>
using StackCoroutine = coroutine_traits<stack<T>, T>;

// 使用示例
StackCoroutine<int>::promise_type::stack_type generator() {
    co_yield 1;
    co_yield 2;
    co_yield 3;
}

auto s = generator();
while(!s.empty()) {
    cout << s.top() << " ";
    s.pop();
}

20.2 硬件加速

利用SIMD指令优化批量操作：

cpp复制class SIMDStack {
    alignas(64) vector<float> data;
public:
    void push4(const float vals[4]) {
        if(data.size() + 4 > data.capacity()) {
            data.reserve(data.capacity() * 2);
        }
        
        #ifdef __AVX2__
            __m128 v = _mm_load_ps(vals);
            _mm_store_ps(&data[data.size()], v);
            data.resize(data.size() + 4);
        #else
            data.insert(data.end(), vals, vals + 4);
        #endif
    }
    
    void pop4(float result[4]) {
        if(data.size() < 4) throw runtime_error("Not enough elements");
        
        #ifdef __AVX2__
            __m128 v = _mm_load_ps(&data[data.size() - 4]);
            _mm_store_ps(result, v);
        #else
            copy(data.end() - 4, data.end(), result);
        #endif
        
        data.resize(data.size() - 4);
    }
};