民和；投影boost多索引迭代器的最大值

我面临一个基于多索引容器中迭代器的投影值的排序问题。下面是完整的代码。我在这里删除的是调用

SellOrderRecord

，因为调用的函数是相同的

GenerateData

，但预期结果不同，即：；在

BuyOrderRecord

中使用前10条最小记录时，应产生前10条最大记录

我强制迭代到500，假设我将得到该范围内的Max/Min值，这是错误的。我需要获取的是前10名的唯一价格和数量总和，如果价格是重复的

出厂价10数量5；价格9数量4；价格8数量7。。。。n

同样的情况下，当我试图获取顶部10分钟的价格与数量

使用printf生成的（在生成数据中注释）显示，即使我使用

std:：less

对其进行排序，一条记录在购买记录的末尾有Max，而另一个持有者在末尾有Min result。我认为两者都应该是最小到最大或最大到最小。完整的实际代码是共享的

namespace bip = boost::interprocess;
namespace bmi = boost::multi_index;

struct MIOrder_Message /// For Data
{
    // STREAM_HEADER Global_Header;
    // char Message_Type;

    MIOrder_Message(Order_Message _Ord)
        : Timestamp(_Ord.Timestamp), Order_Id(_Ord.Order_Id), Token(_Ord.Token),
        Order_Type(_Ord.Order_Type), Price(_Ord.Price),
        Quantity(_Ord.Quantity) {
            //  std::cout << " Insert data for Token "<< _Ord.Token<<std::endl;
        }

    long Timestamp;
    double Order_Id;
    int Token;
    char Order_Type;
    int Price;
    int Quantity;
};
/// Order_Message and MIOrder_Message are almost identical
typedef bip::allocator<MIOrder_Message,
                       bip::managed_shared_memory::segment_manager>
    shared_struct_allocator;

enum {
    ORDERVIEW,
    TOKENVIEW,
    PRICEVIEW,
    TYPEVIEW,
};

typedef bmi::multi_index_container<
    MIOrder_Message,
    bmi::indexed_by<
        bmi::ordered_unique<bmi::tag<struct Order_Id>, BOOST_MULTI_INDEX_MEMBER( MIOrder_Message, double, MIOrder_Message::Order_Id)>,
        bmi::ordered_non_unique<bmi::tag<struct Token>, BOOST_MULTI_INDEX_MEMBER( MIOrder_Message, int, MIOrder_Message::Token)>,
        bmi::ordered_non_unique<bmi::tag<struct Price>, BOOST_MULTI_INDEX_MEMBER( MIOrder_Message, int, MIOrder_Message::Price), std::less<int>>,
        bmi::ordered_non_unique<bmi::tag<struct Order_Type>, BOOST_MULTI_INDEX_MEMBER(MIOrder_Message, char, Order_Type)> >,
        shared_struct_allocator
    > Order_Set;

typedef bmi::nth_index<Order_Set, ORDERVIEW>::type Order_view;
typedef bmi::nth_index<Order_Set, TOKENVIEW>::type Token_View;
typedef bmi::nth_index<Order_Set, PRICEVIEW>::type Price_View;

typedef std::map<int, int> _PricePoint;

_PricePoint GenerateData(int _TKN, std::pair<Order_Set *, std::size_t> OrderRecord, bool IsReverse = false) {

  _PricePoint CurrentPrice;

  if (OrderRecord.second > 0) {

    Token_View::const_iterator t1 =
        OrderRecord.first->get<TOKENVIEW>().find(_TKN);

    Price_View::const_iterator it2 = OrderRecord.first->project<PRICEVIEW>(t1);

    int icount = 0;

    int Price = 0;

    while (icount < 500)
    /// I am forcefully iterating to 500 assuming that i will
    /// get Max value within that range. What i need to fetch is
    /// Top 10 unique Price and sum its Qty if Price is repeated.
    /// Ex. Price 10 Qty 5 ; Price 9 Qty 4; Price 8 Qty 7 .... n
    /// Same is the case when I am trying to fetch top 10 Min Price with Qty.
    {
      auto val = std::next(it2, icount);

      if (val->Token == _TKN) {
        // printf("  Bid Data Found for token %d , Price %d , Qty %d , Time %li
        // , OrderNumber %16f , icount %d  \n
        // ",val->Token,val->Price,val->Quantity,val->Timestamp,val->Order_Id,icount);

        CurrentPrice[val->Price] += val->Quantity;

        Price = val->Price;
      }
      icount++;
    }
    std::cout << " Bid Price " << Price << std::endl;
  }

  return CurrentPrice;
}

int main() {

  bip::managed_shared_memory segment(bip::open_or_create, "mySharedMemory", 20ull<<20);

  Order_Set::allocator_type alloc(segment.get_segment_manager());
  Order_Set * BuyOrderRecord = segment.find_or_construct<Order_Set>("MCASTPORT0BUY")(alloc);

  if (BuyOrderRecord->empty()) {
  }

  while (true) {
    int _TKN = 49732;

    _PricePoint CurrentPrice = GenerateData(_TKN, std::make_pair(BuyOrderRecord, 1), true);

    std::cout << "=========================================================" << std::endl;
    sleep(2);
  }

  return 0;
}

名称空间bip=boost:：进程间；
命名空间bmi=boost:：multi_索引；
数据的struct MIOrder\u Message//
{
//流头全局头；
//字符消息类型；
订单信息（订单信息）
：时间戳（订单时间戳）、订单Id（订单Id）、令牌（订单令牌），
订单类型（订单类型）、价格（订单价格），
数量（订单数量）{
//std:：cout get（）.find（_TKN）；
价格视图：：常量迭代器it2=OrderRecord.first->project（t1）；
int-icount=0；
国际价格=0；
while（i计数<500）
///我强制迭代到500，假设我会
///获取该范围内的最大值。我需要获取的是
///前10名唯一价格，如果价格重复，则将其数量相加。
///出厂价10数量5；价格9数量4；价格8数量7….n
///同样的情况下，当我试图获取顶部10分钟的价格与数量。
{
auto val=std:：next（it2，icount）；
如果（val->Token==\u TKN）{
//printf（“找到令牌%d、价格%d、数量%d、时间%li的投标数据
//，订单号%16f，i数量%d\n
//“，val->Token，val->Price，val->Quantity，val->Timestamp，val->Order\u Id，icount）；
当前价格[val->Price]+=val->Quantity；
价格=价值->价格；
}
icount++；
}
std:：cout您从不检查std:：next（it2，icount）

的结果是否有效

很可能不是。毕竟，

it2

只是

\u TKN

找到的元素，投射在订单价格指数上。如果

\u TKN

恰好在订单集中有最高的价格，那么

it2

已经是最后一个元素了

Price_View::const_iterator it2 = OrderRecord.first->project<PRICEVIEW>(t1);

有序组合键接受部分键，因此可以执行以下操作：

auto range = OrderRecord.first->get<Composite>().equal_range(boost::make_tuple(_TKN));

auto range=OrderRecord.first->get（）.equal_range（boost:：make_tuple（_TKN））；

您从不检查std:：next（it2，icount）的结果是否有效

很可能不是。毕竟，

it2

只是

\u TKN

找到的元素，投射在订单价格指数上。如果

\u TKN

恰好在订单集中有最高的价格，那么

it2

已经是最后一个元素了

Price_View::const_iterator it2 = OrderRecord.first->project<PRICEVIEW>(t1);

有序组合键接受部分键，因此可以执行以下操作：

auto range = OrderRecord.first->get<Composite>().equal_range(boost::make_tuple(_TKN));

auto range=OrderRecord.first->get（）.equal_range（boost:：make_tuple（_TKN））；

无论你做什么，都要让你的样本自我包含（，）。这是你的样本：还要注意，格式是为人准备的。无论你做什么，都要让样本自我包含（，）。这是您的示例：请注意，格式是为humansThanks@sehe it worked设置的。很抱歉示例不完整。谢谢@sehe it worked。很抱歉示例不完整。