Question

struct Limit
    {
    float Price;
    int size;
    int Volume;
    struct Limit *Parent;
    struct Limit *ltChild;
    struct Limit *rtChild;
    struct list_head* Order;
    };
typedef struct Limit Limit;

struct Order
    {   
     double idNum;
     bool BuySell;
         int shares;
     float limitPrice;
         char* entryTime;
     char* eventTime;
         struct list_head ord_Queue;
    };
typedef struct Order Order;
void AddOrder(Order* newOrder,Limit* Limit,HXmap* OrderMap)
 {
    list_add_tail(&newOrder->ord_Queue,Limit->Order);
    HXmap_add(OrderMap,&newOrder->idNum,newOrder);
    Limit->size++;
    Limit->Volume +=newOrder->shares;

 }
void ModifyOrder(float oLimit, int oShares,float nLimit,int nShares,HXmap* LimitMap,HXmap* OrderMap, oBook* OrderBook)
{
    Limit* ParentLimit = (Limit*)HXmap_get(LimitMap,&oLimit);
    if(ParentLimit==NULL)
    {
        printf("ERRONEOUS ORDER\n");
        return;
    }
    struct list_head *pos;
    pos = ParentLimit->Order->next;
    Order* Ord= NULL;
        while(pos!=ParentLimit->Order)   
    {
        Ord = list_entry((pos),Order,ord_Queue);
        if(Ord->shares==oShares)         
        break;                               //found the order
        else pos = pos->next;
    }
    if(pos==ParentLimit->Order && Ord->shares!=oShares)
        {
            printf("ORDER NOT FOUND\n");
            return;
        }
    if(oLimit==nLimit)
    {
        ParentLimit->Volume  = (ParentLimit->Volume + nShares)-oShares;
        Ord->shares = nShares;
    }
    else
    {
               //delete from list
        Ord->ord_Queue.next->prev = Ord->ord_Queue.prev;
        Ord->ord_Queue.prev->next = Ord->ord_Queue.next;
          ParentLimit->size--;
        HXmap_del(OrderMap,&Ord->idNum);
        if(ParentLimit->Volume==Ord->shares)
        {
            if(Ord->BuySell==1)
            OrderBook->buyTree = RemoveLimit(OrderBook->buyTree,ParentLimit,LimitMap);
            else
            OrderBook->sellTree = RemoveLimit(OrderBook->sellTree,ParentLimit,LimitMap);
        }
        else
        ParentLimit->Volume-=Ord->shares;
            Ord->limitPrice = nLimit;
            Ord->shares = nShares;
            INIT_LIST_HEAD(&Ord->ord_Queue);            
            ParentLimit = HXmap_get(LimitMap,&nLimit);
            if(ParentLimit==NULL)
            {
                ParentLimit = Limit_init(nLimit);
                if(Ord->BuySell==1)
                OrderBook->buyTree= AddLimit(OrderBook->buyTree,ParentLimit,LimitMap);
                else
                OrderBook->sellTree = AddLimit(OrderBook->sellTree,ParentLimit,LimitMap);
            }
            AddOrder(Ord,ParentLimit,OrderMap);
    }

}

好吧，这是一个很长的代码，但其中很多都是纯粹直观的。 [它使用list.h内核链接列表及其关联函数。可以找到有关KLL的更多信息here]这个想法是，当以特定价格（其财务代码）修改预先存在的订单的消息到达时，它从原旧价格的先前“队列”中删除订单（ModifyOrder()中的ParentLimit）通过查询地图找到新限价结构的地址，如果它不存在，则创建新限制并添加订单否则它只是添加它。

现在，我输入了以特定限价修改订单的相同信息。传递消息之前的配置：

Limit Price : 181.25, two orders of 250 shares each.

当我通过时，第一个修改消息，修改250个共享的第一个订单，从181.25到181.35（不存在先前的限制，因此它将创建一个新限制并将其添加到树中），控件最终流向{ {1}}因此，添加订单。附加AddOrder()函数的定义，虽然它非常简单，并调用AddOrder()将其添加到列表中。

在第一次修改（和添加订单）之后，DDD给了我这种情况：

list_add_tail()

这表明已成功添加订单到队列。

当我传递第二条消息以相同的旧价格（181.25到181.35）修改另一个订单并查询地图以找到新限价的地址时，

情况是：

Address of ParentLimit: 0x804f1d0
Address of            ->Order: 804f710
Contents of                   ->next: 804dec4
Contents of                   ->prev: 804dec4

Address of Order->ord_Queue (just inserted): 0x804dec4
Contents  of Order->ord_Queue->prev: 0x804f710
Contents of Order->ord_Queue->next: 0x804f710

这意味着，某种程度上所做的改变并不是永久性的。我不知道为什么会发生这种情况。

Answer 1

根据您对查询位置的描述，这是您期望的行为。在您查询地图以获取新价格的ParentLimit之前，这些行将从链接列表中删除订单：

    Ord->ord_Queue.next->prev = Ord->ord_Queue.prev;
    Ord->ord_Queue.prev->next = Ord->ord_Queue.next;

澄清一下：Limit.Order是一个指针。它会跟随您的列表头，即使您将其移动到其他列表。因此，如果您只有一个订单，则从旧列表中删除最终会跟随指向新列表的指针。您需要将其设置为嵌入式结构，或者为新旧列表保留一个空的虚拟头。

对指针的更改不是永久性的

1 个答案: