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

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)的先前“队列”中的订单通过查询 map 找到新限价结构的地址，如果不存在，则创建新限价并添加order else 它只是添加它。

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

限价:181.25，两个订单，每个订单 250 股。

当我通过时，第一个修改消息，将 250 股的第一个订单从 181.25 修改为 181.35(不存在先前的限制，因此它将创建一个新的限制并将其添加到树中)，控制最终流向 AddOrder() 因此，添加订单。附加了 AddOrder() 函数的定义，尽管它非常简单并调用 list_add_tail() 将其添加到列表中。

第一次修改(和添加订单)后，DDD 给我这种情况:

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

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

当我通过第二条消息以相同的旧价格(181.25 到 181.35)修改另一个订单并查询 map 以找到新限价的地址时，

情况是:

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

这意味着，不知何故所做的更改不是永久性的。我不知道为什么会这样。

Answer 1

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

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

---

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