声明一个整型队列对象，插入五个整数，压入队列C++

可以使用STL中的queue容器来实现整型队列对象的声明、插入整数和压入队列的操作。具体代码如下：

#include <iostream>
#include <queue>

using namespace std;

int main()
{
    queue<int> myQueue; // 声明整型队列对象
    int num;
    
    // 插入五个整数
    for(int i = 0; i < 5; i++)
    {
        cout << "请输入第" << i + 1 << "个整数：";
        cin >> num;
        myQueue.push(num);
    }
    
    // 输出队列中的元素
    cout << "队列中的元素为：";
    while(!myQueue.empty())
    {
        cout << myQueue.front() << " ";
        myQueue.pop();
    }
    cout << endl;
    
    return 0;
}

输出结果为：

请输入第1个整数：1
请输入第2个整数：2
请输入第3个整数：3
请输入第4个整数：4
请输入第5个整数：5
队列中的元素为：1 2 3 4 5

相关问题

C++用链表 LinkedList 实现队列类。在 main 函数中会声明一个整型队列对象，插入 5 个整数，压入队列，再依次取出并显示出来。

好的，我可以为您提供 C++ 用链表 LinkedList 实现队列类的代码，您可以在 main 函数中进行测试。以下是代码：

#include <iostream>
using namespace std;

// 链表节点结构体
struct ListNode {
    int val; // 数据域
    ListNode* next; // 指针域
    ListNode(int x) : val(x), next(NULL) {}
};

// 队列类
class Queue {
private:
    ListNode* front; // 队头指针
    ListNode* rear; // 队尾指针
public:
    // 构造函数
    Queue() : front(NULL), rear(NULL) {}
    // 判断队列是否为空
    bool empty() {
        return front == NULL;
    }
    // 入队操作
    void push(int x) {
        ListNode* node = new ListNode(x);
        if (empty()) {
            front = rear = node;
        } else {
            rear->next = node;
            rear = node;
        }
    }
    // 出队操作
    void pop() {
        if (empty()) {
            return;
        }
        ListNode* node = front;
        front = front->next;
        if (front == NULL) {
            rear = NULL;
        }
        delete node;
    }
    // 获取队头元素
    int getFront() {
        return front->val;
    }
    // 获取队尾元素
    int getRear() {
        return rear->val;
    }
};

int main() {
    Queue q;
    // 插入 5 个整数，压入队列
    for (int i = 1; i <= 5; i++) {
        q.push(i);
    }
    // 依次取出并显示出来
    while (!q.empty()) {
        cout << q.getFront() << " ";
        q.pop();
    }
    cout << endl;
    return 0;
}

运行结果如下：

1 2 3 4 5

编写程序queue.h，用链表实现队列（或栈）类。在测试程序lab9_3.cpp 中声明一个整型队列（或栈）对象，插入5个整数，压入队列（或栈），再依次取出并显示出来。

好的，我可以帮你编写 queue.h，这里提供一份链式队列的实现代码，你可以参考一下：

#ifndef QUEUE_H_
#define QUEUE_H_

#include <iostream>

template<typename T>
class Queue
{
private:
    struct Node
    {
        T item;
        Node* next;
        Node(const T& i, Node* n = nullptr) : item(i), next(n) {}
    };
    Node* front;
    Node* rear;
    int size;
public:
    Queue() : front(nullptr), rear(nullptr), size(0) {}
    ~Queue()
    {
        Node* temp;
        while (front != nullptr)
        {
            temp = front;
            front = front->next;
            delete temp;
        }
    }
    bool is_empty() const { return size == 0; }
    int get_size() const { return size; }
    void clear() { *this = Queue(); }
    void enqueue(const T& item)
    {
        Node* temp = new Node(item);
        if (front == nullptr)
        {
            front = temp;
            rear = temp;
        }
        else
        {
            rear->next = temp;
            rear = temp;
        }
        ++size;
    }
    T dequeue()
    {
        if (is_empty())
        {
            std::cerr << "Queue is empty." << std::endl;
            exit(EXIT_FAILURE);
        }
        T item = front->item;
        Node* temp = front;
        front = front->next;
        delete temp;
        --size;
        return item;
    }
    T peek() const
    {
        if (is_empty())
        {
            std::cerr << "Queue is empty." << std::endl;
            exit(EXIT_FAILURE);
        }
        return front->item;
    }
};

#endif

然后你可以在测试程序lab9_3.cpp中创建一个整型队列对象，并进行入队、出队操作，代码如下：

#include <iostream>
#include "queue.h"

int main()
{
    Queue<int> q;
    q.enqueue(1);
    q.enqueue(2);
    q.enqueue(3);
    q.enqueue(4);
    q.enqueue(5);

    while (!q.is_empty())
    {
        std::cout << q.dequeue() << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果为：

1 2 3 4 5