Funzione con tipo di ritorno matrice in C

Question

Ho la seguente funzione in C:

int[] function(int a){ 
    int * var = (int*)malloc(sizeof(int)*tags); 
    .... 
} 

*var è un puntatore ad un array var?

In caso affermativo, come è possibile restituire l'array (var) nella funzione?

Answer 1

Non è davvero possibile restituire una matrice da una funzione, ma un puntatore:

int * function(int a){ 
    int * var = malloc(sizeof(int)*tags); 
    //.... 
    return var; 
} 

Answer 2

In C un array è fondamentalmente lo stesso tipo di un puntatore a un elemento dell'array. Quindi char [] è fondamentalmente char *

Non dimenticare di tenere traccia delle dimensioni dell'array, inoltre ho notato che i tag sembrano essere una variabile globale, il più delle volte è una buona idea evitare la global variabili

Ecco qualche esempio di codice:

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

int* foo(size_t arrSize){ 
    int* arr = (int*) malloc(sizeof(int)*arrSize); 
    return arr; 
} 


int main (int argc, char** argv){ 
    printf("Printing array:\n"); 
    int* arr = foo(42); 
    for(int i=0; i <42; i++){ 
     arr[i]=i; 
    } 

    for (int i=0; i < 42; i++){ 
     printf("Element: %d: %d\n", i, arr[i]); 
    } 
    free(arr); 
    return 0; 
} 

Answer 3

ne dite:

int* function(int tags){ 
    int * var = malloc(sizeof(int)*tags); 
    //.... 
    return var; 
} 

Array e puntatori al tipo di elemento di base sono (soprattutto) anche in C/C++, quindi è possibile restituire un puntatore al primo elemento di un array e utilizzarlo come se fosse l'array stesso.

Nota, il codice ha un parametro di input a, ma utilizzando tags per allocare la memoria per l'array. Ho ipotizzato nel codice sopra che si desidera utilizzare il parametro di input a tale scopo

Inoltre, sarà necessario chiamare free() sul puntatore restituito da function in precedenza, quando non si utilizza più la matrice, per evitare perdite di memoria . malloc sopra alloca memoria sufficiente per contenere tags numero di int s, quindi l'array è equivalente a int var[tags];

UPDATE: cast rimosso per malloc s' ritorno

Answer 4

Questo codice sottostante potrebbe chiarire un po' come matrice e puntatori opere. La funzione assegnerà la memoria per le variabili int "tags", quindi inizializzerà ciascun elemento con un numero e restituirà il segmento di memoria che punta alla matrice. Dalla funzione principale ciclicheremo e stamperemo l'elemento dell'array, quindi libereremo la memoria non più necessaria.

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

int *function(unsigned int tags) { 
     int i; 
     int *var = malloc(sizeof(int)*tags); 

     for (i=0; i < tags; i++) { 
       var[i] = i; 
     } 

     return var; 
} 

int main() { 
     int *x; 
     int i; 

     x = function(10); 
     for (i=0; i < 10; i++) { 
       printf("TEST: %i\n", x[i]); 
     } 

     free(x); x=NULL; 

     return 0; 
} 

Answer 5

In C, le funzioni non possono restituire tipi di array. Per i vostri scopi, si vuole restituire un puntatore a int:

int *function(int a) 
{ 
    int *var = malloc(sizeof *var * tags); // where is tags defined? 
             // are you sure you don't mean a here? 
    ... 
    return var; 
} 

Ciò allocare un blocco di memoria abbastanza grande da contenere tags valori interi e assegnare l'indirizzo del primo elemento di quel blocco a var. Si noti che var è un puntatore a int, non un puntatore a un array di int. Quel puntatore è ciò che viene restituito dalla funzione.

è possibile utilizzare l'oprerator indice su un puntatore espressione come se fosse un array, in questo modo:

int a = ...; 
int *arr = function(a); 
... 
arr[0] = 0; 
arr[1] = 1; 
... 

arr è un'espressione puntatore, non un'espressione array, così sizeof arr restituirà la dimensione del tipo di puntatore, non della dimensione del blocco di memoria a cui punta (per questo, vorrai tenere traccia del numero di elementi che hai assegnato separatamente).