递归函数中malloc的使用：array函数实现的内存分配困惑

Alright, let's work through this problem step by step. First up, I spot a small issue with your function declaration: returning int doesn't make sense if you need to hand back the copied character array. I'll assume that's a typo and adjust it to return char* instead—otherwise, there's no way to pass the allocated memory back to the caller.

Here's how to handle recursive memory allocation and element copying without helper functions, while avoiding stack array resets:

Core Approach #

The idea is to break the problem down recursively:

• Handle the base case (length 0) first, returning NULL since there's nothing to copy.
• For each recursive call, first process the substring starting at str+1 with length length-1.
• Allocate memory for the current full-length array, copy the result of the recursive call into the latter part of this new array.
• Fill in the first element of the new array based on your "specific element" condition.
• Free the memory from the recursive call (we don't need it anymore after copying) to avoid leaks.

Example Implementation #

Let's use "copy uppercase letters" as the "specific element" condition—you can swap this out for your own logic easily:

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

char* array(char *str, int length) {
    // Base case: no elements to process
    if (length == 0) {
        return NULL;
    }

    // Recursively process the remaining substring
    char* sub_array = array(str + 1, length - 1);

    // Allocate memory for the current full-length array
    char* copied = malloc(length * sizeof(char));
    if (copied == NULL) {
        // If malloc fails, clean up previously allocated memory to avoid leaks
        free(sub_array);
        perror("Failed to allocate memory");
        return NULL;
    }

    // Copy the recursive result into the latter part of our new array
    if (sub_array != NULL) {
        memcpy(copied + 1, sub_array, (length - 1) * sizeof(char));
        free(sub_array); // Release the sub-array memory now that we've copied it
    }

    // Apply your "specific element" logic here
    if (isupper((unsigned char)str[0])) {
        copied[0] = str[0]; // Keep the uppercase character
    } else {
        copied[0] = '\0';   // Replace non-matching elements with null (adjust as needed)
    }

    return copied;
}

// Example usage
int main() {
    char input[] = "AbC123XYZ";
    int len = strlen(input);

    char* result = array(input, len);
    if (result != NULL) {
        printf("Original: %s\n", input);
        printf("Copied (uppercase only): ");
        for (int i = 0; i < len; i++) {
            if (result[i] != '\0') {
                putchar(result[i]);
            } else {
                putchar('_'); // Visual placeholder for non-matching elements
            }
        }
        putchar('\n');

        free(result); // Don't forget to free the allocated memory!
    }
    return 0;
}

Key Notes #

• Memory Management: Every time we get a sub_array from recursion, we copy its contents then immediately free it—this prevents memory leaks from piling up across recursive calls.
• Error Handling: If malloc fails, we clean up any already allocated memory from deeper recursive calls before returning an error.
• Customization: Swap out the isupper check with your own condition for "specific elements" (e.g., checking for a particular character, digits, etc.).
• Caller Responsibility: The caller must free the returned array once they're done with it to avoid memory leaks.

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