Question

我有一个结构，其中包含一个指向函数的指针和一个指向函数的指针数组。我将第一个指针（而不是数组）作为函数的参数传递，该函数应该告诉我整数数组是否已排序（它可以升序还是降序，这由compFct定义，即参数中给出的指向函数的指针。）

不幸的是，该函数正在更改我的结构中的指针数组中的值（而没有更改我的指针值对参数中给定的函数）。

使用gdb，我设法知道何时对阵列进行更改。在printSorted函数中的第一个printf之后，似乎已对其进行了修改。

我的typedef：

typedef int (*PtrCompFct)(int, int);
typedef int (*PtrSortFct)(int*, int, int, PtrCompFct);

结构：

typedef struct
{
    int nbFct;
    PtrCompFct compFct;
    PtrSortFct *sortFct;
} SortCompFct_s;

这是我调用函数的方式（userChoices是SortCompFct_s类型）：

printSorted(myArr, myArrSize, userChoices->compFct);

改变我结构的功能：

int printSorted(int *arr, int arrSize, PtrCompFct compFct)
{
    for (int i=0; i<(arrSize-1); i++)
    {
        if (compFct(arr[i+1], arr[i]))
        {
            //this is when my array of pointers to function is modified
            printf("The array isn't sorted\n\n");
            return 0;
        }
    }
    printf("The array is sorted\n\n");
    return 1;
}

在printf之前有gdb：

(gdb) print main::userChoices->sortFct[0]
$36 = (PtrSortFct) 0x5555555548ea <quickSort>

及之后：

(gdb) print main::userChoices->sortFct[0]
$37 = (PtrSortFct) 0x7fffffffddc0

如您所见，指向我的quickSort函数的指针已被修改。

编辑：包括简化和可验证的代码，事实是，即使使用printSorted函数，此代码也可以正常工作

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

typedef int (*PtrCompFct)(int, int);
typedef int (*PtrSortFct)(int*, int, int, PtrCompFct);

typedef struct
{
    int nbFct;
    PtrCompFct compFct;
    PtrSortFct *sortFct;
} SortCompFct_s;

typedef SortCompFct_s *PtrSortCompFct_s;

void initTab(int *arr, int arrSize)
{
    time_t t;
    srand(time(&t));
    for (int i=0; i<arrSize; i++)
    {
        arr[i] = rand();
    }
}

int ascendingSort(int elmt1, int elmt2)
{
    return (elmt1 < elmt2);
}

int descendingSort(int elmt1, int elmt2)
{
    return (elmt1 > elmt2);
}

void switche(int *arr, int ind1, int ind2)
{
    int temp = arr[ind1];
    arr[ind1] = arr[ind2];
    arr[ind2] = temp;
}

int bubbleSort(int *arr, int ind1, int ind2, PtrCompFct fctComp)
{
    int sorted;
    for (int i=ind1; i<ind2; i++)
    {
        sorted = 1;

        for (int j=0; j<ind2; j++)
        {
            if (fctComp(arr[j+1], arr[j]))
            {
                switche(arr, j, j+1);
                sorted = 0;
            }
        }

        if (sorted) return 0;
    }

    return 0;
}

void printArr(int *arr, int arrSize)
{
    for (int i=0; i<arrSize; i++)
    {
        printf("%16d\n", arr[i]);
    }
}

int printSorted(int *arr, int arrSize, PtrCompFct compFct)
{
    for (int i=0; i<arrSize-1; i++)
    {
        if (compFct(arr[i+1], arr[i]))
        {
            //this is when my array of pointers to function is modified
            printf("The array isn't sorted\n\n");
            return 0;
        }
    }
    printf("The array is sorted\n\n");
    return 1;
}

PtrSortCompFct_s menu(void)
{
    PtrSortCompFct_s userChoices;
    PtrSortFct arrSortFct[] = {bubbleSort};

    if ((userChoices = malloc(3*sizeof(int))) != NULL)
    {
        userChoices->nbFct = 1;
        userChoices->compFct = ascendingSort;
        userChoices->sortFct = arrSortFct;
    }

    return userChoices;
}

int main(void)
{
    int arrSize = 10;
    int arr[arrSize];
    initTab(arr, arrSize);
    PtrSortCompFct_s userChoices;

    if ((userChoices = malloc(3*sizeof(int))) != NULL) userChoices = menu();

    printArr(arr, arrSize);
    printSorted(arr, arrSize, userChoices->compFct);

    userChoices->sortFct[0](arr, 0, arrSize-1, userChoices->compFct);

    printArr(arr, arrSize);
    printSorted(arr, arrSize, userChoices->compFct);

    return 0;
}

Answer 1

在printf之前使用gdb，我有：...和之后：

问题的根本原因在于userChoices->sortFct的初始化方式（尚未显示执行该初始化的代码）。

该数组指向 dangling 堆或堆栈内存，而对printf的调用将覆盖该内存。

if ((userChoices = malloc(6*sizeof(int))) != NULL) userChoices = menu();

该代码完全是伪造的：为userChoices分配堆内存，然后立即用userChoices的返回值覆盖menu()只会泄漏内存。如评论中所述，6*sizeof(int)的大小也完全是伪造的。

我猜您的menu()看起来像这样：

struct SortCompFct_s* menu()
{
   struct SortCompFct_s ret;
   ret.compFct = &SomeFunc;
   ret.sortFct = malloc(...);
   ret.sortFct[0] = &quickSort;
   return &ret;    // Oops: returning address of a local!
}

如果这实际上是您所做的，那么悬挂堆栈正是您的问题。您应该打开最大的编译器警告（如果使用GCC，则为-Wall -Wextra），这样编译器会告诉您您做错了什么。

更新：

我的猜测已经接近：

PtrSortCompFct_s menu(void)
{
    PtrSortCompFct_s userChoices;
    PtrSortFct arrSortFct[] = {bubbleSort};

    if ((userChoices = malloc(3*sizeof(int))) != NULL)
    {
        userChoices->nbFct = 1;
        userChoices->compFct = ascendingSort;
        userChoices->sortFct = arrSortFct;
    }

    return userChoices;
}

问题是userChoices->sortFct指向局部（堆栈）变量arrSortFct。从menu返回后，该局部变量变为无效，并且此时userChoices->sortFct指向悬空堆栈（如我所猜）。

这里是编写此函数的正确方法（为清楚起见，省略了对malloc返回的错误检查）：

PtrSortCompFct_s menu(void)
{
    PtrSortCompFct_s userChoices;
    PtrSortFct arrSortFct[] = {bubbleSort};

    if ((userChoices = malloc(sizeof(*userChoices)) != NULL)
    {
        userChoices->nbFct = 1;
        userChoices->compFct = ascendingSort;
        userChoices->sortFct = malloc(sizeof(arrSortFct));
        memcpy(userChoices->sortFct, arrSortFct, sizeof(arrSortFct));
    }

    return userChoices;
}

您还应该像这样修复main：

PtrSortCompFct_s userChoices;

PtrSortCompFct_s userChoices = menu();
... use userChoices ...

free(userChoices->sortFct);
free(sortFct);
return 0;

为什么调用函数会修改参数中未提供的指向函数的指针数组的值？

1 个答案: