为什么此代码会导致程序崩溃？

Question

void gameListType::sortAscending() {

    nodeType<gameType> *current;
    nodeType<gameType> *next;
    nodeType<gameType> *prev;
    nodeType<gameType> *temp;

    temp = first;
    prev = first;
    current = first;
    next = current->link;

    while ( current->link !=NULL){
        if (current ==first){
             if (current->info.getPrice() > next->info.getPrice()){
            temp->info = current -> info;
            temp->link = next ->link;
            next -> link = temp;
            current = temp;
            delete temp;
            }
        }
        else if (current !=first ){
            if (current->info.getPrice() > next->info.getPrice()){
                temp->info = current->info;
                temp-> link = next ->link;
                next->link = temp;
                prev->link = next;
                current = temp;
                delete temp;
            }
        }
        if(current == first){
            prev = first;
        }
        else{
            prev = prev->link;
        }
        current = current ->link;
        next = next->link;
    }
}

running this code will cause my program to crash, any ideas? This is basically to sort the items in a CUSTOM linked list. It apparently only crashes after the loop has completed once, so the second loop is the problem as to why it is crashing.

Answer 1

Your code crashes because you treat temp variable as if it was pointing to a temporary object, but it actually points to one of the objects in the list you're sorting.

Take this simple path:

temp = first;
prev = first;
current = first; // temp == first and current == first, so temp == current
next = current->link;

while ( current->link !=NULL){          // true
    if (current ==first){               // true
        if (current->info.getValue() > next->info.getValue()){ // true
            temp->info = current->info; // temp == current, so nothing changes
            temp->link = next->link;    // temp == current, so current->link = next->link
            next -> link = temp;        // temp == current, so next->link = current
            current = temp;             // temp == current, so nothing changes
            delete temp;                // temp == current, so delete both temp and current
        }
    }
// ...
    current = current ->link;         // but we deleted current! segfault

Exactly the same problem is present in the else if block (there's a bit of code duplication in your sample). The problem is eliminated by creating a new temporary object for the temp variable. Note that it's enough to have a temporary for info alone:

if (current->info.getValue() > next->info.getValue()){
    // No need to mess with pointers here, current and next are advanced later
    // Bonus points for using a swap function instead
    InfoClass temp = current->info;
    current->info = next->info;
    next->info = temp;
}

This approach doesn't modify next and current pointers, thus fixing another problem in your function (ie next->link pointing to current instead of current->link pointing to next ).

---

I want to address one other point here, which is that even when fixed, your function doesn't actually perform a sort; it only performs a single pass of bubble sort which 'pushes' the biggest value in the list to the right position (that is: the end of the list). Even when implemented correctly, bubble sort is an inefficient algorithm with a quadratic complexity in the average case.

Merge sort is a common algorithm used to sort lists. Alternatively, depending on what you're sorting, it might be beneficial to simply copy data into a vector, sort it with std::sort and reconstruct the list from the sorted data (this approach is simplest to implement and least error-prone, though merge sort is always fun to write).