Linux正常运行的C++代码在Windows添加节点时崩溃求助

The error code 0xC0000005 corresponds to an access violation (the Windows equivalent of Linux's SIGSEGV), which almost always means your program is trying to read or write to invalid memory—usually due to an uninitialized pointer or a pointer that’s no longer valid. Given your code works on Linux but crashes on Windows with input 1 10 1 11, here’s the most probable fix and breakdown:

Common Root Cause: Incorrect Pointer Passing in Insert Function #

The biggest culprit here is likely how you’re passing the root pointer to your insert function. If you’re passing it by value instead of by reference or pointer-to-pointer, modifications to the root inside the function won’t affect the original pointer in your main code. This leaves the original root uninitialized (holding garbage memory) even after inserting the first node.

On Linux, uninitialized stack memory sometimes accidentally holds 0 (nullptr) by chance, letting the first insert work. On Windows, that uninitialized memory is almost always an invalid address, so when you try to insert the second node, you’re accessing garbage memory and crashing immediately.

Wrong Code Example (The Crash Culprit) #

void insert(Node* root, int key) {
    if (root == nullptr) {
        root = new Node{key, nullptr, nullptr}; // Only modifies a local copy of root
        return;
    }
    // Rest of insertion logic...
}

int main() {
    Node* root; // Uninitialized! Garbage value on Windows
    insert(root, 10);
    insert(root, 11); // Crash happens here—root is still garbage
    return 0;
}

Corrected Code (Using Reference-to-Pointer) #

This ensures changes to the root inside the function affect the original pointer in main:

void insert(Node*& root, int key) { // Pass root by reference
    if (root == nullptr) {
        root = new Node{key, nullptr, nullptr}; // Modifies the original root
        return;
    }
    // Rest of insertion logic (e.g., insert left/right based on key)
    if (key < root->key) {
        insert(root->left, key);
    } else {
        insert(root->right, key);
    }
}

int main() {
    Node* root = nullptr; // Explicitly initialize to nullptr
    insert(root, 10);
    insert(root, 11); // Now works correctly
    return 0;
}

Alternative Fix (Using Pointer-to-Pointer) #

If you prefer C-style pointer handling:

void insert(Node** root, int key) {
    if (*root == nullptr) {
        *root = new Node{key, nullptr, nullptr};
        return;
    }
    if (key < (*root)->key) {
        insert(&((*root)->left), key);
    } else {
        insert(&((*root)->right), key);
    }
}

int main() {
    Node* root = nullptr;
    insert(&root, 10);
    insert(&root, 11);
    return 0;
}

Additional Checks to Prevent Future Crashes #

• Always initialize pointers: Never leave pointers like root uninitialized—set them to nullptr explicitly. Windows is stricter about accessing uninitialized memory than Linux in most cases.
• Validate memory allocation: If you’re using malloc instead of new, ensure you cast the result to Node* (required in C++) and check for allocation failure:

  Node* newNode = (Node*)malloc(sizeof(Node));
  if (newNode == nullptr) {
      // Handle allocation failure (e.g., log error and exit)
  }
  

• Check for null before dereferencing: Any time you access pointer->member, confirm pointer isn’t nullptr first to avoid access violations.

内容的提问来源于stack exchange，提问作者user4945113