返回整数时触发Segmentation Fault（段错误）

Hey there! Welcome to Stack Overflow—glad you reached out with this tricky issue. Segmentation faults usually boil down to illegal memory access, so let’s walk through the most likely causes and fixes for your vote aggregation function.

Common Causes of Your Segmentation Fault #

• Unallocated or incorrectly sized target array: If you’re writing to a struct votes pointer that’s either NULL or hasn’t been allocated enough memory to hold all matching votes, your program will try to write to invalid memory space. This is one of the most frequent culprits here.
• Shallow copying of char pointers: Your votes struct has char *category and char *nominee members. If you just copy the pointer values instead of the actual string content, you might end up with dangling pointers (if the original strings are freed later) or accidentally access uninitialized memory if the target struct’s pointers weren’t set properly.
• Out-of-bounds array access: If your loop to iterate the original votes array uses an incorrect length or loop condition, you’ll read memory outside the array’s bounds. This can corrupt the stack/heap, and the fault might only trigger when you try to return the integer count (since that’s when the program’s state is being cleaned up).
• Null pointer dereferencing: If you’re passing a NULL pointer to your function (either the source array or the target array pointer) and don’t handle that case, accessing its members will immediately cause a segfault.

Step-by-Step Fixes & Debugging Tips #

1. Properly Allocate Memory for the Target Array #

First, count how many votes match your criteria (same number and category), then allocate exactly that much memory for the target array. Always check if malloc succeeds—returning NULL means allocation failed, and you need to handle that error:

// First, count matching votes
int match_count = 0;
for (int i = 0; i < source_array_length; i++) {
    // Replace with your actual matching logic
    if (source[i].number == target_number && strcmp(source[i].category, target_category) == 0) {
        match_count++;
    }
}

// Allocate target array
struct votes *target = malloc(match_count * sizeof(struct votes));
if (target == NULL) {
    perror("Failed to allocate target array");
    return -1; // Or handle error appropriately
}

2. Deep Copy String Members #

Don’t just copy the char pointers—use strdup() (or malloc + strcpy) to duplicate the actual string content. This prevents dangling pointers and ensures your target array has its own valid string data:

// When copying a matching vote
target[idx].number = source[i].number;
target[idx].category = strdup(source[i].category);
target[idx].nominee = strdup(source[i].nominee);
idx++;

Note: Don’t forget to free these strings later (and the target array itself) to avoid memory leaks!

3. Validate Loop Bounds & Inputs #

• Double-check that your loop uses the correct length of the source array (e.g., for (int i = 0; i < source_len; i++)—not <=).
• Add guard clauses at the start of your function to handle invalid inputs:

  if (source == NULL || source_len <= 0) {
      return 0; // Or error code
  }
  

4. Use Debugging Tools to Pinpoint Exact Line #

If you’re still stuck, use tools like gdb or valgrind to find the exact line causing the fault:

• Compile your code with debug symbols: gcc -g your_code.c -o your_program
• Run in gdb: gdb ./your_program, then run to trigger the fault. Type backtrace to see the call stack and identify the problematic line.
• valgrind ./your_program will flag all illegal memory accesses and memory leaks with detailed messages.

Example Working Code Snippet #

Here’s a simplified version of how your function could look, incorporating the fixes above:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct votes {
    int number;
    char *category;
    char *nominee;
};

int aggregate_matching_votes(struct votes *source, int source_len, int target_num, char *target_cat, struct votes **target_out) {
    if (source == NULL || source_len <= 0 || target_cat == NULL || target_out == NULL) {
        return 0;
    }

    // Count matching votes
    int count = 0;
    for (int i = 0; i < source_len; i++) {
        if (source[i].number == target_num && strcmp(source[i].category, target_cat) == 0) {
            count++;
        }
    }

    // Allocate target array
    *target_out = malloc(count * sizeof(struct votes));
    if (*target_out == NULL) {
        perror("malloc failed");
        return -1;
    }

    // Copy matching votes
    int idx = 0;
    for (int i = 0; i < source_len; i++) {
        if (source[i].number == target_num && strcmp(source[i].category, target_cat) == 0) {
            (*target_out)[idx].number = source[i].number;
            (*target_out)[idx].category = strdup(source[i].category);
            (*target_out)[idx].nominee = strdup(source[i].nominee);
            idx++;
        }
    }

    return count;
}

// Cleanup helper
void free_votes_array(struct votes *arr, int len) {
    for (int i = 0; i < len; i++) {
        free(arr[i].category);
        free(arr[i].nominee);
    }
    free(arr);
}

int main() {
    struct votes sample_votes[] = {
        {1, "president", "Alice"},
        {1, "president", "Bob"},
        {2, "senator", "Charlie"},
        {1, "president", "Alice"}
    };
    int sample_len = sizeof(sample_votes)/sizeof(sample_votes[0]);
    struct votes *aggregated = NULL;
    int agg_len = aggregate_matching_votes(sample_votes, sample_len, 1, "president", &aggregated);

    if (agg_len > 0) {
        printf("Aggregated %d votes:\n", agg_len);
        for (int i = 0; i < agg_len; i++) {
            printf("#%d: %s (%s)\n", aggregated[i].number, aggregated[i].nominee, aggregated[i].category);
        }
        free_votes_array(aggregated, agg_len);
    }

    return 0;
}

内容的提问来源于stack exchange，提问作者João Faisca