¿Cómo hacer que un tipo de retorno de matriz de la función C?

He intentado devolver el nombre de la matriz como se muestra a continuación. Básicamente, estoy tratando de hacer que la prueba de función devuelva una matriz que pueda usarse en main. ¿Podría aconsejarme qué necesito leer más para saber cómo realizar una función como esta?

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

Recibo los compiler errors:

 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 

Las funciones no pueden devolver matrices en C.

Sin embargo, pueden devolver estructuras. Y las estructuras pueden contener matrices …

Puede devolver una matriz devolviendo un puntero (las matrices decaen a los punteros). Sin embargo, eso sería malo en su caso, ya que entonces estaría devolviendo un puntero a una variable local, y eso da como resultado un comportamiento indefinido. Esto se debe a que la memoria a la que apunta el puntero ya no es válida después de que la función regresa, ya que el espacio de stack ahora es reutilizado por otras funciones.

Lo que debe hacer es pasar la matriz y su tamaño como argumentos a la función.

También tiene otro problema en su código, y es que utiliza una matriz de tamaño dos, pero escribe en un tercer elemento.

Deberá asignar memoria en el montón y devolver un puntero. C no puede devolver matrices de funciones.

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

La primera línea de los mensajes de error significa exactamente lo que dice: ha declarado que la función devuelve un int , pero intenta devolver un puntero.
El mayor problema (como lo indica la segunda línea de los mensajes de error) es que la matriz a la que intenta devolver un puntero es una matriz local y, por lo tanto, quedará fuera del scope cuando las funciones regresen y dejen de ser válidas.
Lo que debe hacer es asignar dinámicamente una matriz (es decir, una porción de memoria continua) usando malloc o new y devolverle un puntero. Y, por supuesto, asegúrate de liberar la memoria una vez que hayas terminado.

Desafortunadamente, C no admite la devolución de matrices arbitrarias ni estructuras anónimas de funciones, pero hay dos soluciones alternativas.

La primera solución es crear una estructura que contenga la matriz en ella. Tendrá el mismo tamaño que la matriz y se asignará en la stack, lo que garantiza la ubicación del espacio.

p.ej

 typedef struct { int arr[5]; } my_array1; typedef struct { int values[3]; } factorFunctionReturnType_t; 

La segunda solución es inventar un conjunto de memoria estático (por ejemplo, un arreglo con malloc / free personalizado solo para este conjunto), y esto le permitirá asignar dinámicamente la memoria de este conjunto, nuevamente, devolviendo un puntero al espacio de stack contiguo, que Es por definición una matriz.

p.ej

 #include  static uint8_t static_pool[2048]; 

Luego, implemente my_alloc, my_free que administra este grupo de memoria específico, de nuevo asegurando que la memoria creada está en la stack, y la memoria ya es propiedad de su aplicación apriori (mientras que malloc puede asignar memoria previamente no accesible por aplicación o falla si no hay suficiente memoria y no comprobó el retorno fallido).

La tercera solución es hacer que la función devuelva una variable local a una función de callback; esto asegura que una vez que la función finalice, puede usar el resultado sin dañar la stack porque la función que utiliza la memoria estará sobre el scope que contiene la stack.

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

Esto es más eficiente que una agrupación de memoria no astackda que necesita tomar decisiones para evitar la fragmentación, más eficiente que una agrupación de memoria astackda que solo coloca el resultado en la parte superior de la stack porque no necesita copiar la cadena, y más seguro para subprocesos porque el valor de retorno de la función no corre el riesgo de ser sobrescrito por otro subproceso (a menos que se use un locking).

Lo curioso es que todos los progtwigs de “paradigma de progtwigción funcional” terminan enfatizando que puede escribir progtwigs en C sin ningún tipo de malloc encadenando las funciones de callback, asignándolas efectivamente a la stack.

Esto tiene un efecto secundario interesante al hacer que las listas vinculadas ya no se vuelvan hostiles al caché (ya que las listas vinculadas de callback asignadas en la stack estarán todas juntas en la stack, lo que le permite hacer cosas como la manipulación de cadenas en tiempo de ejecución sin ningún tipo de mallocs, y permite construiste entradas de usuario de tamaño desconocido sin hacer mallocs.

C no recomienda devolver la dirección de una variable local fuera de la función, por lo que tendría que definir la variable local como variable estática.

 #include  /* 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; } 

Mi sugerencia sería pasar en una matriz para rellenar:

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

Con este método, no tiene que preocuparse por la asignación y no necesita liberar la matriz más adelante.

También arreglé el tamaño de la matriz, para que no escribas fuera de ella con el tercer elemento. Recuerde que las matrices de C se declaran con “la cantidad que desea” y luego se indexan desde 0 ... (how_many-1) , por lo que [2] en una matriz declarada con [2] sale de la matriz.

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

También es posible que desee asegurarse de que los índices que está configurando realmente existan en su matriz como lo he señalado anteriormente

Aquí hay otra manera de devolver la matriz:

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

La estática indica que la variable se asignará de manera que permanecerá en la memoria. Entonces, si tiene un tamaño fijo para el valor y desea que permanezca en la memoria entre las llamadas a funciones, esta es una forma de hacerlo.

En primer lugar, no puede devolver una matriz desde una función en C directamente. Lo que puede hacer es que puede devolver la dirección de la matriz en esa función. En ese caso, la función se verá así:

 int* test(int size, int x){ /* function body */ return factorFunction; } 

Y para recibir la matriz, necesitará un puntero, no una matriz.

Entonces, en lugar de usar int factors[2]; tienes que usar int *factors; en su función main .

En segundo lugar, incluso si devuelve la dirección de la matriz, este código no funcionará; porque está intentando devolver la dirección de una matriz local; Que no existirá después de la ejecución de la función. Una forma fácil de resolver este problema es declarar la matriz local ( factorFunction en este caso) estática.

Teniendo en cuenta estos dos asuntos, la test función se verá así:

 int* test(int size, int x){ static int factorFunction[size]; /* function body */ return factorFunction; } 

En primer lugar, a menos que tenga C99 que tenga VLA s, el tamaño del arreglo debe ser constante en C. No puede usar la siguiente statement:

 int factorFunction[size]; 

En segundo lugar, está intentando devolver una matriz creada en la función que se eliminará fuera del scope.

Para evitar esto, puede tomar una matriz como parámetro en la función de prueba o crear una matriz dinámicamente con la función malloc . Por cierto, su función de test puede devolver el puntero a la matriz actualizada.

Un código muy básico y una explicación muy básica CÓMO Devolver la matriz de una función definida por el usuario a la función principal … ¡Espero que ayude! A continuación, he dado un código completo para que alguien entienda cómo funciona exactamente. 🙂 🙂

 #include using namespace std; int * function_Random()// function with returning pointer type of integer { static int arr[100]; cout<<"We are Inside FunctionRandom"<