c - 如何从 C 函数中创建数组返回类型？

Question

我试图返回数组名称，如下所示。基本上我试图让函数测试返回一个可以在main中使用的数组。你能告诉我我需要阅读更多内容以了解如何执行这样的功能吗？

#include <stdio.h>

int test(int size, int x){
    int factorFunction[size];    
    factorFunction[0] = 5 + x;
    factorFunction[1] = 7 + x;
    factorFunction[2] = 9 + x;
    return factorFunction;
}

int main(void){
    int factors[2];
    factors = test(2, 3);
    printf("%d", factors[1]);
    return 0;
}

我收到编译器错误：

smallestMultiple.c:8: warning: return makes integer from pointer without a cast
smallestMultiple.c:8: warning: function returns address of local variable
smallestMultiple.c: In function ‘main’:
smallestMultiple.c:13: error: incompatible types in assignment

score 15 · Accepted Answer

函数不能在 C 中返回数组。

但是，它们可以返回结构。结构可以包含数组...

score 14 · Accepted Answer

您可以通过返回指针来返回数组（数组衰减为指针）。但是，在您的情况下这会很糟糕，因为您将返回一个指向局部变量的指针，这会导致未定义的行为。这是因为返回的指针指向的内存在函数返回后不再有效，因为堆栈空间现在被其他函数重用。

您应该做的是将数组及其大小都作为参数传递给函数。

您的代码中还有另一个问题，那就是您使用了一个大小为 2 的数组，但写入了第三个元素。

score 9 · Accepted Answer

您将需要在堆上分配内存并返回一个指针。C 不能从函数返回数组。

int* test(int size, int x)
{
    int* factorFunction = malloc(sizeof(int) * size);    
    factorFunction[0] = 5 + x;
    factorFunction[1] = 7 + x;
    factorFunction[2] = 9 + x;
    return factorFunction;
}

score 3 · Accepted Answer

错误消息的第一行正是它所说的：您已将函数声明为返回一个int，但您尝试返回一个指针。
更大的问题（正如错误消息的第二行告诉您的那样）是您尝试返回指针的数组是本地数组，因此当函数返回并且不再有效时将超出范围。你应该做的是使用or
动态分配一个数组（即一块连续的内存）并返回一个指向它的指针。当然，请确保在完成后释放内存。mallocnew

score 3 · Accepted Answer

不幸的是，C 不支持从函数返回任意数组或匿名结构，但有两种解决方法。

第一个解决方法是创建一个包含数组的结构。它将具有与数组相同的大小，在堆栈上分配以确保空间局部性。

例如

typedef struct {
    int arr[5];
} my_array1;

typedef struct {
    int values[3];
} factorFunctionReturnType_t;

第二种解决方法是发明一个静态内存池（例如，仅针对该数组具有自定义 malloc/free 的数组），这将有效地允许您从该池中动态分配内存，再次有效地返回一个指向连续堆栈空间的指针，这根据定义是一个数组。

例如

#include <stdint.h>
static uint8_t static_pool[2048];

然后实现管理这个特定内存池的 my_alloc、my_free，再次确保创建的内存在堆栈上，并且内存已经由您的应用程序先验拥有（而 malloc 可能会分配以前应用程序无法访问的内存，或者如果内存不足则崩溃并且没有检查失败返回）。

第三种解决方法是让函数将局部变量返回给回调函数；这确保一旦函数完成，您可以使用结果而不会破坏堆栈，因为使用内存的函数将位于包含堆栈的范围之上。

#include <stdint.h>
#include <stdio.h>

void returnsAnArray(void (*accept)(void *)) {
    char result[] = "Hello, World!";    

    accept(result);
}

void on_accept(void *result) {
    puts((char *)result);
}

int main(int argc, char **argv)
{
    returnsAnArray(on_accept);

    return 0;
}

这比非堆栈式内存池更有效，后者需要做出决策以避免碎片，比堆栈式内存池更有效，后者只需将结果放在堆栈顶部，因为它不需要复制字符串，等等线程安全，因为函数的返回值不会被另一个线程覆盖（除非使用了锁）。

有趣的是，所有“函数式编程范例”程序最终都强调您可以通过链接回调函数来编写没有任何 malloc 的 C 程序，从而有效地在堆栈上分配。

这有一个有趣的副作用，使链表不再缓存恶意（因为分配在堆栈上的回调链表都将在堆栈上彼此靠近，这使您可以在没有任何 malloc 的情况下执行运行时字符串操作等操作，并让你建立了未知大小的用户输入，而不做任何 malloc。

score 2 · Accepted Answer

C 不提倡将局部变量的地址返回到函数外部，因此您必须将局部变量定义为静态变量。

#include <stdio.h>

/* function to generate and return random numbers */
int * getRandom( ) {

   static int  r[10];
   int i;

   /* set the seed */
   srand( (unsigned)time( NULL ) );

   for ( i = 0; i < 10; ++i) {
      r[i] = rand();
      printf( "r[%d] = %d\n", i, r[i]);
   }

   return r;
}

/* main function to call above defined function */
int main () {

   /* a pointer to an int */
   int *p;
   int i;

   p = getRandom();

   for ( i = 0; i < 10; i++ ) {
      printf( "*(p + %d) : %d\n", i, *(p + i));
   }

   return 0;
}

score 0 · Accepted Answer

#include <stdio.h>

#include <stdlib.h>

int* test(int size, int x){
    int *factorFunction = (int *) malloc(sizeof(int) * size);    
    if( factorFunction != NULL ) //makes sure malloc was successful
    {
        factorFunction[0] = 5 + x;
        factorFunction[1] = 7 + x;
        factorFunction[2] = 9 + x; //this line won't work because your array is only 2 ints long

    }
return factorFunction;
}

int main(void){
    int *factors;
    factors = test(2, 3);
    printf("%d", factors[1]);
    //just remember to free the variable back to the heap when you're done
    free(factors);
    return 0;
}

you also might want to make sure that the indexes you are setting actually exist in your array as I've noted above

score 0 · Accepted Answer

Firstly, Unless you have C99 which has VLAs, the array size should be constant in C. You can not use the statement below:

int factorFunction[size];

Secondly, you are trying to return an array created in the function which will be deleted out of the scope.

To avoid this, you can take an array as parameter in test function or create an array dynamically with malloc function. Btw your test function can return pointer to updated array.

score 0 · Accepted Answer

我的建议是传入一个数组来填写：

void test(int size, int factors[], int x){
    factorFunction[0] = 5 + x;
    factorFunction[1] = 7 + x;
    factorFunction[2] = 9 + x;
}

int main(void){
    int factors[3];
    test(3, factors, 3);
    printf("%d", factors[1]);
    return 0;
}

使用这种方法，您不必担心分配，以后也无需释放数组。

我还修正了数组的大小，所以你不要用第三个元素在它之外写。请记住，C 数组是用“你想要多少”声明的，然后从开始索引0 ... (how_many-1)，所以[2]用声明的数组[2]在数组之外。

score 0 · Accepted Answer

首先，您不能直接从 C 中的函数返回数组。您可以做的是，您可以在该函数中返回数组的地址。在这种情况下，该函数将如下所示：

int* test(int size, int x){

    /* function body */

    return factorFunction;
}

要接收数组，您将需要一个指针 - 而不是数组。

所以，int factors[2];你必须int *factors;在你的main函数中使用，而不是使用。

其次，即使你返回数组的地址，这段代码也不行；因为您试图返回本地数组的地址；函数执行后将不存在。解决此问题的一种简单方法是将本地数组（factorFunction在本例中）声明为静态的。

考虑到这两个问题，函数test将如下所示：

int* test(int size, int x){

    static int factorFunction[size];

    /* function body */

    return factorFunction;
}

score 0 · Accepted Answer

这是传回数组的另一种方法：

    int test(){
        static int factorFunction[3];    
        factorFunction[0] = 5 + x;
        factorFunction[1] = 7 + x;
        factorFunction[2] = 9 + x;
        return factorFunction;
    }

静态表示变量将以保留在内存中的方式分配。因此，如果您有一个固定大小的值并希望它在函数调用之间保留在内存中，这是一种方法。

score 0 · Accepted Answer

  // example for to create a array in function and it return using pointer
  //if you want use malloc use header #include <stdlib.h>
      int * printsquares(int a[],int size){  //to declare aa function

      int* e = malloc(sizeof(int) * size);  //to create array using malloc
       for(int i=0;i<size;i++){    
             e[i]=i*i;       //assign the square root values
      }



   return e;


 }

score 0 · Accepted Answer

要记住两点：

如果要从函数返回一维数组，则必须声明一个返回指针的函数。
C 不提倡将局部变量的地址返回到函数外部，因此您必须将局部变量定义为静态变量。

参考这个链接： https ://www.tutorialspoint.com/cprogramming/c_return_arrays_from_function.htm

score -1 · Accepted Answer

关于如何将数组从用户定义的函数返回到主函数的非常基本的代码解释希望它有所帮助。下面，我写了一个完整的代码来制作。请原谅 c++ 语言，但是如果您需要 c 程序，请随时发表评论

#include<iostream>
using namespace std;

int * function_Random()// function with returning pointer type of integer
{
     static int arr[100];
     cout<<"We are Inside FunctionRandom"<<endl;
    for(int i=0;i<100;i++)//loop to add elements in array
    {
        arr[i]=rand();//rand() function to put random numbers generated by system
        cout<<"\t"<<arr[i]; //to show how our array will look
    }
    cout<<endl<<endl;//endl for end line to look well formatted 
    return arr;
}
int main()
{


    int *arrptr; //pointer to get back base address of array
    arrptr=function_Random();//function that returns base address
    cout<<"We are Inside Main"<<endl;
    for(int j=0;j<100;j++)
    {
         cout<<"\t"<<arrptr[j];//returned base address has complete link of array that's why it is able to print the array:contiguous memory locations.
    }       
    return 0;//nothing to return that's why 0
}

c - 如何从 C 函数中创建数组返回类型？

14 回答 14

Related

Reference