数组传入函数并返回指针：30层电梯楼层差作业编译错误求助

Hey Dominic, let's work through this elevator problem together! It sounds like you're hitting compile issues when passing an array to a function and trying to get a pointer back—this is super common when you're first learning how arrays and pointers interact, so let's break down the fixes step by step.

First, let's cover the most common mistakes that would cause your code to fail to compile (or behave incorrectly even if it does compile):

• Returning a pointer to a local array: If your function creates an array inside itself and returns its address, that array gets destroyed when the function exits, leaving you with a "dangling pointer" (this is a huge bug, even if it compiles).
• Incorrect function parameter declarations: When passing an array to a function, it decays to a pointer, but you still need to declare the parameter correctly (and always pass the number of valid elements, not just the total array length).
• Mismatched array lengths: Your 30-length array holds only 5 valid floors—you need to track how many actual floors are pressed, not just the array's total size.

Solution 1: Pass a Result Array to the Function (Safer for Beginners) #

The simplest and safest approach is to have your main code create the array for storing differences, then pass it to your calculation function along with the floor array and count of pressed floors. Here's a complete working example:

#include <stdio.h>

// Calculates differences between consecutive floors and stores them in the result array
void calculateFloorDifferences(int floors[], int numFloors, int differences[]) {
    for (int i = 1; i < numFloors; i++) {
        differences[i-1] = floors[i] - floors[i-1];
        // If you want absolute differences (in case floors are out of order), use:
        // differences[i-1] = abs(floors[i] - floors[i-1]);
    }
}

int main() {
    // Initialize your 30-length array with pressed floors (rest are 0, but we track valid count)
    int pressedFloors[30] = {5, 10, 14, 19, 29};
    int numPressed = 5; // Number of actual floors pressed
    int floorDifferences[29]; // Max possible differences: 30 floors -> 29 differences

    // Call the function to calculate differences
    calculateFloorDifferences(pressedFloors, numPressed, floorDifferences);

    // Print the results
    printf("Pressed floors: ");
    for (int i = 0; i < numPressed; i++) {
        printf("%d ", pressedFloors[i]);
    }
    printf("\nFloor differences: ");
    for (int i = 0; i < numPressed - 1; i++) {
        printf("%d ", floorDifferences[i]);
    }
    printf("\n");

    return 0;
}

Solution 2: Return a Dynamically Allocated Pointer (If You Need to Return a New Array) #

If you really need the function to return a pointer to a new array of differences, you'll need to use dynamic memory allocation with malloc. Just remember to free the memory later to avoid leaks:

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

// Returns a dynamically allocated array of differences (must be freed by caller)
int* calculateFloorDifferences(int floors[], int numFloors) {
    if (numFloors < 2) {
        return NULL; // Not enough floors to calculate differences
    }

    // Allocate memory for numFloors - 1 differences
    int* differences = malloc(sizeof(int) * (numFloors - 1));
    if (differences == NULL) {
        printf("Memory allocation failed!\n");
        return NULL;
    }

    for (int i = 1; i < numFloors; i++) {
        differences[i-1] = floors[i] - floors[i-1];
    }

    return differences;
}

int main() {
    int pressedFloors[30] = {5, 10, 14, 19, 29};
    int numPressed = 5;

    int* differences = calculateFloorDifferences(pressedFloors, numPressed);
    if (differences == NULL) {
        return 1;
    }

    printf("Floor differences: ");
    for (int i = 0; i < numPressed - 1; i++) {
        printf("%d ", differences[i]);
    }
    printf("\n");

    // Don't forget to free the dynamically allocated memory!
    free(differences);
    differences = NULL; // Good practice to avoid dangling pointers

    return 0;
}

Key Notes to Avoid Future Issues: #

• Always track the number of valid elements in your array, not just its total length. A 30-length array with only 5 used elements needs that count passed to functions.
• Never return a pointer to a local array (declared inside a function without static—even static has caveats). Dynamic allocation or passing a result array are the safe options.
• If your elevator might receive out-of-order floor presses (e.g., someone presses 29 then 5), you'll want to sort the floor array first using qsort before calculating differences.

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