C++ 将数据容器传输到不同的类

我将一个报价向量从Trader类传递到Simulator类。然后哪个类将其传递到auctioneer类。似乎有点混乱，有人能发现它吗

以下是代码的一部分： 错误：199应在“&”标记之前使用主表达式

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdlib>
#include <iomanip>

using namespace std;

const int NUMSELLER = 1;
const int NUMBUYER = 1;
const int NUMBIDS = 20;
const int MINQUANTITY = 1;
const int MAXQUANTITY = 30;
const int MINPRICE =100;
const int MAXPRICE = 150;
int s=0;
int trdId;

// Bid, simple container for values
struct Bid {
        int bidId, trdId, qty, price;
        char type;

        // for sort and find.
        bool operator<(const Bid &other) const { return price < other.price; }
        bool operator==(int bidId) const { return this->bidId == bidId; }
};

// alias to the list, make type consistent
typedef vector<Bid> BidList;

// this class generates bids!
class Trader {
private:
        int nextBidId;

public:
        Trader();
        Bid getNextBid();
        Bid getNextBid(char type);

        void loadRange(BidList &, int size); // generate a number of bids
        void loadRange(BidList &, char type, int size);
        void submitBids();
};

Trader::Trader() : nextBidId(1) {}

#define RAND_RANGE(min, max) ((rand() % (max-min+1)) + min)

Bid Trader::getNextBid() {
        char type = RAND_RANGE('A','B');
        return getNextBid(type);
}

Bid Trader::getNextBid(char type) {
        for(int i = 0; i < NUMSELLER+NUMBUYER; i++)
     {
        if (s<10){trdId=0;type='A';}
        else {trdId=1;type='B';}
        s++;
        int qty = RAND_RANGE(MINQUANTITY, MAXQUANTITY);
        int price = RAND_RANGE(MINPRICE, MAXPRICE);
        Bid bid = {nextBidId++, trdId, qty, price, type};
        return bid;
}
}
void Trader::loadRange(BidList &list, int size) {
        for (int i=0; i<size; i++) { list.push_back(getNextBid()); }
}

void Trader::loadRange(BidList &list, char type, int size) {
        for (int i=0; i<size; i++) { list.push_back(getNextBid(type)); }
}

bool compareBidList(Bid one, Bid two) {

        if (one.type == 'A' && two.type == 'B')
                return (one.price < two.price);

        return false;
}

void sort(BidList &bidlist) { sort(bidlist.begin(), bidlist.end(), compareBidList); }
//-----------------------------------------------------------------

//To go through the bidlist (after sorting) in reverse direction.
//If the first entry  found  is an "A", ignore it
//Look for the first "A" to match it, and so on..........
//If "B" quantity is greater than the matching "A" quantity, copy the "A"
//To matchedBids, copy the "B" to matchedBids but with  reduced quantity equal to the "A"
//REPLACE the "B" in the original vector with an NEW "B"


//---------------------------AUCTIONEER-------------------------------------------

class Auctioneer {

public:

Auctioneer (const BidList& vec);   // copy constructor

typedef vector<Auctioneer> vec;
typedef vector<Auctioneer> buyers;
typedef vector<Auctioneer> sellers;
typedef Auctioneer* iterator;
typedef const Auctioneer* const_iterator;
//typedef size;
typedef Auctioneer value_type;

vector<Bid> list;
//typedef vector<Bid> BidList;
//typedef vector<Bid> iterator = BidList;

void accept_bids(vector<Bid> lst) {list = lst;}
void storeBids(){copy(list.begin(), list.end(),
                 bids.begin());}
void displayBids(){cout << "Ok the bids" << endl;} ;

void matchBid();
void calculateProfit();
vector<Auctioneer>::const_iterator b, e;
// new functions to return iterators
iterator begin() { return data; }
const_iterator begin() const { return data; }

iterator end() { return limit; }
const_iterator end() const { return limit; }

private:
string bids;
iterator data;
iterator limit;

};
//---------------------------------SIMULATOR-------------------------------------------
class Simulator {
    Trader trader;
    Auctioneer auctioneer;
    //SmartTrader  strader;

public:
   vector<Bid> list;
   char type;

   void run();
};

void Simulator::run()
    {
      trader.loadRange(BidList &list); //calling from Base class
      auctioneer.receiveBids(list);//receiver
      auctioneer.displayBids;    // print from receiver
    }

//Simulator::accept_bids(bid_vector::const_iterator begin, bid_vector::const_iterator end))


int main() {
       // Trader Trader;
//        BidList bidlist;
         Auctioneer auctioneer;

        auctioneer.loadRange(bidlist, NUMBIDS);
        show("Bids before sort:", bidlist);
        sort(bidlist);
        show("Bids after sort:", bidlist);

        //count(bidlist);

        //unpair(bidlist);
        //unpair("Bids after sort:", bidlist);

        searchTest(bidlist, 3);
        searchTest(bidlist, 33);
         system("pause");
        return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
常量int numseler=1；
常数int NUMBUYER=1；
常数int NUMBIDS=20；
常量int MINQUANTITY=1；
常量int最大数量=30；
const int MINPRICE=100；
const int MAXPRICE=150；
int s=0；
int-trdId；
//Bid，值的简单容器
结构投标{
int BIDDID、trdId、数量、价格；
煤焦类型；
//用于排序和查找。
布尔运算符bidId==bidId；}
};
//列表的别名，使类型一致
typedef矢量投标清单；
//这个类生成出价！
阶级商人{
私人：
int NEXTBIDD；
公众：
交易员（）；
Bid getNextBid（）；
Bid getNextBid（字符类型）；
void loadRange（BidList&，int size）；//生成多个出价
无效加载范围（BidList&，字符类型，整数大小）；
void submitBids（）；
};
Trader:：Trader（）：nextbidd（1）{}
#定义RAND_范围（最小值，最大值）（（RAND（）%（最大值最小值+1））+min）
出价交易者：：getNextBid（）{
字符类型=随机范围（'A'，'B'）；
返回getNextBid（类型）；
}
出价交易者：：getNextBid（字符类型）{
对于（int i=0；i
在文件顶部或，最好将向量更改为

std::vector

如果不是这样，那么我们需要知道错误发生在哪一行。
您需要包括
，并且您需要在每次使用中完全限定
向量的名称，例如：

void loadRange(std::vector<Bid> & bids) {}

它可能无法识别
BidList
。请确保它已定义或包含在顶部的头文件中，或者至少将
类BidList
放在顶部。不过，您确实需要向我们显示错误所指的行。
很可疑，您有一个BidList类型，但每个行都使用一个向量re else.考虑到您在一个位置使用它作为参考，我猜BidList没有定义。
您的less函数是不够的。给定两个bID a=（bID=3，tID=4，$2.4，20000）和B=（bID=4，tID=11，$2.4，20000）与代码非常相似的代码是不完整的，几乎不可能猜出您看到了什么问题。要做很多事情，我们需要足够完整的代码来重现您的错误。如果没有其他内容，那么了解代码的哪一部分触发了您提到的错误会有很大帮助。不满足于格式正确这里是Mr 340699？在粘贴更多代码之前，请学习如何正确缩进，而不是依赖其他用户为您修复（我的是第二次尝试）。所有代码都应缩进4个空格字符。
使用名称空间可能是一个错误的建议，因为该代码可能来自头文件。我知道……我最好添加一个；）行是199。错误：const之前应该有主表达式。我有名称空间std。我编辑了代码以获得清晰的指导。我有typedef vector BidList；就在struct之后。我生成了出价，但交易者仍然与出价容器堆叠。但是，BidList已定义。我正在模拟器类中创建新的向量，这将分别保存出价。一个用于买家，另一个用于卖家。我在交易者中有一个typedef向量BidList.void loadRange（BidList&list）{}。并且传递了void loadRange（BidList cont&list）{}错误：常量之前应为主表达式。我正在注释代码的这一部分，任务是将出价传递给拍卖商。我希望在第二阶段进行比较。这只是为了测试。您将compareBidList（）作为main（）的一部分传递给std:：sort，因此我假设您希望它正常工作。
std::vector

void loadRange(std::vector<Bid> & bids) {}

void loadRange(std::vector<Bid> cont& bids) {}

bool operator<(const Bid& other) {
      if (price < other.price) return true;
      return bidID < other.bidID; // assuming bidID is unique, otherwise add trade id to the mix
}