返回队列的函数？ 我试图找出队列在C++中如何工作，并且在处理对象时会陷入困境。我似乎只能得到一个返回地址，而不是对象的名称（这是我真正想要的）。当我试图从队列中弹出元素时，它也显示了一个错误。我的代码如下：

Buyer.h文件

#ifndef BUYER_H
#define BUYER_H
#include <string>
#include <queue>
#include "Order.h"
#include "Entity.h"
#include "Seller.h"

class Order;

class Seller;

class Buyer : public Entity {

public:
 Buyer(const std::string &, const std::string &, double);
 virtual ~Buyer() { }; // when step is added make this virtual
 void addSeller(Seller *);
 std::queue<Seller*> getSellers() const;
 void addOrder(Order *);
 std::queue<Order*> getOrders() const;
 virtual void list() const override;
 virtual void step() const override;

private:
 std::queue<Order*> orders;
 std::queue<Seller*> sellers;

};
#endif

\ifndef买方
#定义买方
#包括
#包括
#包括“Order.h”
#包括“实体h”
#包括“卖方h”
阶级秩序；
类别卖方；
类别买方：公共实体{
公众：
买方（常数std:：string&，常数std:：string&，double）；
virtual~Buyer（）{}；//添加步骤时，将此设置为虚拟
卖方（卖方*）无效；
std:：queue getSellers（）常量；
无效订单（订单*）；
std:：queue getOrders（）常量；
虚空列表（）常量覆盖；
虚空步骤（）常量覆盖；
私人：
std：：队列顺序；
std：：排队卖家；
};
#恩迪夫

Buyer.cpp文件

#include <iostream>
#include <ostream>
#include <stdexcept>
#include <string>
#include <queue>
#include "Buyer.h"
#include "Seller.h"
#include "Order.h"
#include "Entity.h"
using namespace std;

Buyer::Buyer(const std::string &name, const std::string &id, double balance)
  : Entity(name, id, balance)
{
  // initialize seller and order queue??
} // Constructor

void Buyer::addSeller(Seller *s) {
  sellers.push(s);
} // addSeller

std::queue<Seller*> Buyer::getSellers() const {
  while(!sellers.empty()) {
    return sellers;
  } // while
} // getSellers

void Buyer::addOrder(Order *o) {
  orders.push(o);
} // addOrder

std::queue<Order*> Buyer::getOrders() const {
  while(!orders.empty()) {
    return orders;
  } // while
} // getOrders

void Buyer::list() const {
  Entity::list();
  std::cout << "Orders:\nOrder contains:";
  std::cout << "\nSellers:\n";
  int i = 0;
  while(!sellers.empty()) {
    std::cout << sellers.front() << "\n";
    sellers.pop();
  } // while
} //list

void Buyer::step() const {
  std::cout << "\nstep enter\n"
            << "step exit\n\n";
} // step

#包括
#包括
#包括
#包括
#包括
#包括“买方h”
#包括“卖方h”
#包括“Order.h”
#包括“实体h”
使用名称空间std；
买方：：买方（常量标准：：字符串和名称，常量标准：：字符串和id，双倍余额）
：实体（名称、id、余额）
{
//初始化卖家和订单队列？？
}//构造函数
无效买方：：添加卖方（卖方）{
卖方。推送；
}//添加卖家
std:：queue Buyer:：getSellers（）常量{
而（！sellers.empty（））{
退货卖家；
}//而
}//getSellers
无效买方：：添加订单（订单*o）{
命令。推（o）；
}//添加顺序
std:：queue Buyer:：getOrders（）常量{
而（！orders.empty（））{
退货订单；
}//而
}//获取订单
无效买家：：列表（）常量{
实体：：列表（）；
std：：cout（这不是一个完整的答案，但它太大了，无法在评论中出现）

可以返回
std:：queue
，以此类推。但是，您需要明确谁拥有被指向的对象，即谁负责删除它们

当您返回一个
std:：queue
时，发生的情况是返回的队列是原始队列的副本，但是所有指针都指向原始队列指向的同一对象。（这是一种“浅副本”）

如果随后
删除返回队列中的任何内容，则会导致原始队列出现故障，因为它将访问已删除的内存

因此，这是一个脆弱的设计，因为尽管
getOrders
是一个常量函数，但调用方很容易导致对象出错

一个“解决方案”是让容器包含
共享的内容，而不是
订单*
。然后一切都会自动发生；调用者可以添加或删除他心中的内容

如果容器不需要包含指针，请考虑使用对象容器：<代码> STD:：队列< /代码>。该方法的好处是默认的复制和移动语义都是正确的。
另一种考虑的方法是：<代码> GoOrthOrthSe（）/<代码>和<代码> GeSaleServer（）/<代码>返回const引用，而不是返回队列的副本。
注意：在
Buyer:：getSellers（）
和
getOrders（）
中，如果它是空的，那么您会在没有返回的情况下从函数末尾掉下来，导致未定义的行为。您需要返回某个内容（返回空队列有什么问题？）或
抛出一个异常。
可能重复的