对指针的更改不是永久的

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（不存在先前的限制，因此它将创建一个新的限制并将其添加到树中），控制最终流向 @ 987654325@ 因此，添加订单。附加了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）修改另一个订单并查询地图以找到新限价的地址时，

情况是：

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

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

Answer 1

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

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

---

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