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

Answer 1

函数无法在C中返回数组。

然而，他们可以返回结构。结构可以包含数组......

Answer 2

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

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

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

Answer 3

您需要在堆上分配内存并返回指针。 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;
}

Answer 4

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

Answer 5

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

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

e.g。

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

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

第二种解决方法是发明一个静态内存池（例如，仅为此数组提供自定义malloc / free的数组），这将有效地允许您从此池动态分配内存，同样有效地返回指向连续堆栈的指针space，根据定义是一个数组。

e.g。

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

然后实现管理此特定内存池的my_alloc，my_free，再次确保创建的内存在堆栈上，并且内存已经由您的应用程序apriori拥有（而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;
}

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

有趣的是，所有＆＃34;功能编程范例＆＃34;程序最后强调你可以通过链接回调函数来编写没有任何malloc的C程序，有效地在堆栈上进行分配。

这有一个有趣的副作用，使链表不再缓存恶意（因为堆栈上分配的回调链接列表都将在堆栈上彼此靠近，这使您可以执行诸如运行时字符串操作之类的操作，而无需任何mallocs ，并允许您构建未知大小的用户输入而无需执行任何malloc。

Answer 6

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;
}

Answer 7

#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;
}

您还可能希望确保您设置的索引实际存在于您的阵列中，如上所述

Answer 8

首先，除非您的C99具有VLA s，否则数组大小应该在C中保持不变。您不能使用以下语句：

int factorFunction[size];

其次，您正在尝试返回在函数中创建的数组，该数组将从范围中删除。

为避免这种情况，您可以将数组作为测试函数中的参数，或使用malloc函数动态创建数组。顺便说一句，你的test函数可以返回指向更新数组的指针。

Answer 9

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

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]超出了数组。

Answer 10

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

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

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

Answer 11

首先，您无法直接从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;
}

Answer 12

要记住两点：

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

请参阅此链接： https://www.tutorialspoint.com/cprogramming/c_return_arrays_from_function.htm

Answer 13

  // 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;


 }

Answer 14

非常非常基本的代码和非常基本的解释如何返回数组从用户定义的函数返回到main函数。希望它帮助！下面我给出了完整的代码，让任何人都能理解它是如何工作的？ :)：）

#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函数中生成数组返回类型？

14 个答案: