Fonction avec tableau de type de retour en C

J’ai la fonction suivante en C:

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

*var est-il un pointeur sur un tableau var ?

Si oui, comment puis-je retourner le tableau ( var ) dans la fonction?

Vous ne pouvez pas vraiment retourner un tableau à partir d’une fonction, mais un pointeur:

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

Ce code ci-dessous pourrait clarifier un peu le fonctionnement des tableaux et des pointeurs. La fonction allouera de la mémoire aux variables “tags” int, puis initialisera chaque élément par un numéro et renverra le segment de mémoire qui pointe vers le tableau. À partir de la fonction principale, nous allons faire un cycle et imprimer l’élément de tableau, puis nous libérerons la mémoire qui n’est plus nécessaire.

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

En C, les fonctions ne peuvent pas renvoyer de types de tableaux. Pour vos besoins, vous souhaitez renvoyer un pointeur sur 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; } 

Cela allouera un bloc de mémoire suffisamment grand pour contenir des valeurs entières pour les tags et assignera l’adresse du premier élément de ce bloc à var . Notez que var est un pointeur sur int , pas un pointeur sur un tableau d’ int . Ce pointeur est ce qui est renvoyé par la fonction.

Vous pouvez utiliser l’opérateur avec indice sur une expression de pointeur comme s’il s’agissait d’un tableau, comme ceci:

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

arr est une expression de pointeur, pas une expression de tableau, donc sizeof arr renverra la taille du type de pointeur, pas la taille du bloc de mémoire sur lequel il pointe (pour cette raison, vous voudrez garder une trace du nombre de éléments que vous avez alloués séparément).

Que diriez-vous:

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

Les tableaux et les pointeurs vers le type d’élément de base sont (principalement) synonymes en C / C ++. Vous pouvez donc renvoyer un pointeur sur le premier élément d’un tableau et l’utiliser comme s’il s’agissait du tableau lui-même.

Notez que votre code a un paramètre d’entrée a , mais utilise des tags pour allouer la mémoire au tableau. J’ai supposé dans le code ci-dessus que vous vouliez utiliser le paramètre d’entrée à cette fin

De plus, vous devrez appeler free() sur le pointeur renvoyé par la function ci-dessus, lorsque vous n’utiliserez plus le tableau, pour éviter les memory leaks. malloc ci-dessus alloue suffisamment de mémoire pour contenir le nombre de tags int s, le tableau est donc équivalent à int var[tags];

MISE À JOUR: retrait de la dissortingbution pour le retour de malloc

En C, un tableau est fondamentalement du même type qu’un pointeur sur un élément du tableau. Donc char [] est fondamentalement char *

N’oubliez pas de garder la trace de la taille du tableau. J’ai aussi remarqué que les balises semblaient être une variable globale. La plupart du temps, il est conseillé d’éviter les variables globales.

Voici un exemple de code:

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