Allocation de mémoire pour le pointeur sortingple

La fonction somefunction() prend un sortingple pointeur en argument.

 int somefunction(tchar ***returnErrors); 

Comment allouer de la mémoire pour le paramètre returnErrors ?

À deviner. . .

Vous pouvez considérer returnErrors comme un pointeur sur un tableau de chaînes.

  1. Le premier * implique un pointeur sur un tableau de tchar (ou une seule chaîne de tchars)
  2. Le second * implique un pointeur sur un tableau de chaînes.
  3. La dernière * est afin que vous puissiez changer returnErrors et renvoyer la nouvelle mémoire.

Pour effacer la mémoire pour cela (exemple idiot, allouer de la mémoire dans SomeFunction)

 tchar ** errors; // Oops it appears I need to pass back two error ssortingngs (+ 1 for null on end, so we know there are no more - thanks tlholaday) errors = malloc(sizeof(tchar*) * 3); // the first ssortingng has length 20 (+ 1 for null terminator) errors[0] = malloc(sizeof(tchar) * 21); // the second ssortingng has length 30 (+ 1 for null terminator) errors[1] = malloc(sizeof(tchar) * 31); // ensure the last is null errors[2] = 0; *returnErrors = errors; 

NB: La fonction appelante doit savoir que SomeFunction a alloué de la mémoire et doit la libérer.

Implémentez-vous une fonction ou appelez-vous une fonction?

Si vous appelez une fonction, il est probable que cette dernière allouera de la mémoire. Il vous suffit donc de lui atsortingbuer un endroit sûr pour griffonner et nettoyer par la suite.

 tchar **theErrors = 0; // a vector of tchar vectors. somefunction(&theErrors); if (theErrors) { // use the error values // free the memory somehow - this is for a null-terminated convention tchar **victim = theErrors; while (*victim) delete[](*victim++); delete[] theErrors; } 

Remarque: J’utilise 0 et supprime [] au lieu de NULL et free car la balise indique c ++.

Cela dépend de ce que “quelque chose” attend. Vous devez enquêter à ce sujet!

Il peut s’attendre à un pointeur sur un tableau de dimension 2 de taille fixe, ou un tableau régulier de dimension 3, ou ???

Dans les cas que j’ai mentionnés, le code pourrait ressembler à

 tchar errors[SIZE1][SIZE2]; somefunction( &errors ); 

ou

 tchar errors[SIZE1][SIZE2][SIZE3]; somefunction( errors ); 

Quelqu’un sait-il comment allouer de la mémoire pour le paramètre returnErrors?

La question est trop générique et on ne peut pas y répondre dans le cas général. Voici juste un exemple d’extrait de code possible qui l’appelle.

 tchar foo; tchar * p_foo = &foo; tchar ** pp_foo = &p_foo; tchar *** ppp_foo = &pp_foo; somefunction(ppp_foo); 

Juste un commentaire: je considérerais votre signature de fonction dangereuse et donc une odeur de code même si elle avait une écanvas de moins.

Aussi, notez:

  • Un pointeur n’est jamais un tableau. C’est une variable qui contient la valeur d’une adresse mémoire, ou NULL.
  • L’adresse qu’un pointeur contient ne correspond pas toujours à l’adresse de départ d’un tableau. int ** p ne fait pas toujours référence à l’adresse de départ d’un int [] [].
  • Un pointeur dont la valeur contient l’adresse de départ d’un tableau n’est pas le meilleur moyen de passer ce tableau en tant que paramètre de fonction. Au lieu de cela, une référence au type de tableau peut être utilisée.
  • Un tableau n’est généralement pas le meilleur moyen de contenir un ensemble de valeurs liées en C ++. std :: vector et autres conteneurs STL doivent être pris en compte. (Cependant, votre question comporte deux langues, C et C ++, sous forme de balises; bien entendu, cela ne s’applique qu’à cette dernière possibilité. Pourquoi les deux balises?)

Il existe deux cas d’utilisation d’un fonction comme votre someFunction () que je voudrais utiliser.

Pour l’initialisation:

 { tchar **returnErrors; initErrors(tchar &returnErrors); /* now returnErrors has a place in memory*/ } int initErrors(tchar ***returnErrors) { *returnErrors = malloc(sizeof(tchar *) * SIZE1) for (i = 0; i < NUM_ELEMENTS; i++) (*returnErrors)[i] = malloc(sizeof(tchar) * SIZE2); /*add checks for malloc failures*/ } 

Tableau passant à une fonction:

 { returnErrors[SIZE1][SIZE2][SIZE3]; someFunciton(returnErrors); } int someFunciton(tchar ***returnErrors) { /*assuming that this is a valid index*/ tchar x = returnErrors[1][1][1]; /*return errors is used as a sortingple array*/ } 

Le pointeur sortingple n’a aucun sens si vous n’avez pas déjà une construction de ce type. Je préférerais plutôt utiliser une classe – ou au moins un conteneur standard. Mais si vous devez savoir, c’est aussi simple que

 tchar ***pointer = (tchar***) malloc(sizeof(tchar**) * amount); 

Je suis plutôt d’accord avec l’ affirmation de tholoray , avec la modification que la fonction renvoie probablement le nombre d’erreurs qu’elle alloue.

 tchar **theErrors = 0; // a vector of tchar vectors. int nErrors = somefunction(&theErrors); if (nErrors > 0) { for (int i = 0; i < nErrors; ++i) { printf(theErrors[i]); free(theErrors[i]); } free(theErrors); } 

Notez que l'utilisation de free ou delete [] dépendra de la manière dont la mémoire a été allouée.