Récupérer taille allouée d'un char* passé en argument d'une fonction

Bonjour,

Je souhaiterais récupérer la taille max ou en quelque sorte le "sizeof" d'un char* passé en argument d'une fonction (et donc sans fournir la taille en argument, juste le char*).

Voici un exemple pour illustrer:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

void f(char* str) { // ici besoin de la taille de str pour y copier une longue chaine de caractère constante // du genre strncpy(str, ???, constString); }   int main() { char buf[32];   f(buf);   return 0; }

---

J'ai essayé plusieurs manières en vain, je précise que je souhaite trouver une solution sans fournie la taille en argument:

Code:

---

void f(char* str, unsigned int size);

---

Le problème c'est que je pensais pouvoir récupérer la taille par un sizeof(str) mais cela renvoie la taille d'un pointeur (4 octets).
Je précise que "buf" est vide ou plutot non-initialisé avant d'être passé à la fonction f(), donc strlen(str) donnera zéro.

Voilà, donc si vous avez une solution, je suis preneur.

Merci de votre aide.

Hello

Même avec une allocation dynamique (ce qui n'est pas le cas dans ton exemple), il n'y a pas de manière standard de le faire. Même si tu trouves une astuce tordue pour le faire, je le déconseilles fortement.

Si tes appels sont toujours similaires à ton exemple c'est à dire basé sur des tableaux de char et pas des pointeurs, un template peut te rendre service:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

#include <iostream> #include <string>   template <std::size_t Size> std::string char_array_to_str(char const (&arg)[Size]) { return std::string(arg, Size); }   int main() { char roger[3] = {'a','b','c'}; std::cout << char_array_to_str(roger) << std::endl; }

---

Merci pour ton aide.

Par contre, je ne cherche pas à convertir mon char* en string, je cherche simple à recupérer sa taille pour pouvoir le remplir sans "déborder" la-dite taille.

Pour commencer, sizeof(n'importe quoi*) = sizeof(void*) = la taille d'un pointeur.
A la différence d'un tableau (une variable dont le type est truc[]), dont sizeof retournera bien la taille complete.

Tu peux tenter d'utiliser strlen(), mais cela suppose deux choses: ton pointeur n'est pas nul, ca, tu peux le controler, et le contenu est une chaine de caractères au sens du C: une suite de caractère sans '\0', suivi d'un '\0'.

Cela dit, un pointeur général ne connais pas de taille.
Une autre façon de procéder, c'est de passer par la différence entre deux pointeurs... mais il faut les deux pointeurs.

Le soucis est que le code C++ sera compilé sous la forme d 'une DLL, et le tableau est fourni (et alloué statiquement du genre char array[1000]) depuis du code Java (qui charde la DLL C++).

Donc le tableau "reçu" du Java par la DLL est sans doute vide ou plutôt non-initialisé.

Et si c'est correctement designé, l'API doit te fournir la taille du buffer en octet. :weird:
T'aurais pas un peu zappé la documentation de l'API JAVA ? :aie:

En fait, je vais être plus précis.

Il s'gait d'une IHM Java qui appelle du JNI pour charger la DLL C++.

Je m'occupe que du developpement de la DLL C++, donc je doit me comformer aux signatures de fonctions attendues (sans tailles de tableaux, en l'occurence void f(char* str)).

Donc tu ne peux pas connaitre cette taille par magie.
Un pointeur n'est vraiment qu'une adresse.

Par contre, tu as certainement une documentation te disant quelle taille est autorisée.

Non, car comme indiquée précedemment, la chaine arrive vide ou non-initilisée et sera remplie dans la DLL C++.

Code:

---

1 2 3 4 5 6

// DLL C++ void f(char* str) { string sTemp("Portez ce vieux whisky au juge blond qui fume"); strncpy(str, ???, sTemp);// si je mets strlen(str) à la place de ??? ça n'ira car la chaine est vide }

---

On va faire dans l'efficace.

Tu contactes ton copain le plus balèze pour qu'il t'accompagne au meeting avec les JAVAistes.

Et tu dis gentiment à ces crétins de designer CORRECTEMENT leur API JNI ou sinon ton copain sera le bras armée de la théorie de Darwin. :aie:

Je voulais justement eviter d'en arriver à de telles extremités.

Car je pensais me proposer pour faire moi-même les modifs dans JNI, mais le problème est que toutes les autres DLL existantes (dont je ne m'occupe pas) suivent l'interface définit dans le JNI, et que pour qu'elle soit toujours utilisables en Java il faudrait ensuite toutes les modifier pour qu'elle soit chargeables par le JNI (si on ne respecte pas scrupuleusement l'ensemble de fonctions définit et leurs signatures, la DLL crash).

Ce que tu espères faire est strictement impossible.
Une telle méthode doit obligatoirement savoir la taille maximale. Tu as parlé d'un char[1000] plus haut.. qu'en est-il ? :weird:

de deux choses l'une
- tu dois allouer str et t'en charges
-> nécessitera sans doute l'ajout d'une fonction de libération
- tu dois utiliser str, et il te faut la taille maximale possible

Y'a pas de magie, et c'est pas par hasard que toutes les méthodes qui utilisent du char* prennent un paramètre supplémentaire pour connaître leur taille, ou savent la "deviner" à coup de strlen.

Il te reste plus qu'à rajouter la précondition suivante : la chaîne ne contient pas de '\0' sauf le dernier caractère comme le propose leternel.

Code:

---

1 2 3 4

char buf[32]; for (std::size_t i = 0; i < 32; ++i) { buf[i] = 'a'; } buf[31] = '\0'; f(buf);

---

--- --- ---

Ou alors la taille est dans une constante / variable plus ou moins globale.

Changer la signature de la fonction n'est aps possible (pour les raisons evoquées precedement), donc "f(buf, sizeof(buf));" pas possible.

Mettre une taille en globale c'est possible, mais, comment s'assurer que la taille constante est la même que dans le code JNI, exemple:

Code:

---

1 2 3 4 5 6 7

// Code JNI   #define SIZE 1000   ...   char str[SIZE]; // str sera fournit à la DLL C++

---

Code:

---

1 2 3 4 5 6 7 8 9

// Code C++   #define SIZE 1000   void f(char* str) { string sTemp("Portez ce vieux whisky au juge blond qui fume"); strncpy(str, SIZE sTemp); }

---

Donc là OK, mais le problème risque de se corser si des modifs sont faites dans le JNI (j'ai pas la main dessus) tout en continuant d'utiliser la DLL (sans synchroniser les changements):

Code:

---

1 2	// JNI #define SIZE 500

---

Code:

---

1 2 3 4 5 6 7 8

// C++ #define SIZE 1000   void f(char* str) { string sTemp("Portez ce vieux whisky au juge blond qui fume ......... etc"); // chaine de 800 char par exemple strncpy(str, SIZE sTemp); }

---

Là on aura un soucis d'overflow!

Tu peux ajouter une fonction dans la dll ?

Code:

---

std::size_t f_c_str_size() { return 32; }

---

Je pourrais àjouter une fonction usage "interne" de la DLL, mais celle que tu me propose présume que je connaise la taille du tableau, or c'est ce que je cherche à determiner.

Donc si tu as une fonction du genre

Code:

---

std::size_t getSizeArray(char* array);// array chaine non-initilaisée et probablement vide

---

mon problème serait resolu.

Citation:

---

Envoyé par LinuxUser

Je pourrais àjouter une fonction usage "interne" de la DLL, mais celle que tu me propose présume que je connaise la taille du tableau, or c'est ce que je cherche à determiner.

---

Je propose une fonction (qui pourrait juste être une variable globale constante) qui retourne une taille arbitraire et qui "force" (faut écrire ça dans la documentation) la taille du char*.

Si tu veux que la taille du char* puissent varier, il te faut une variable globale non constante qui devra être mise à jour avant l'appel de la fonction (non thread-safe).

Ta signature est bien void f(char*)? dans ce cas, tu reçois une copie d'un pointeur de char.
Donc tu ne peux pas allouer dans ta fonction.

J'en déduis que tu reçois de la mémoire allouée.
Trois choix sont possibles:

1. Cette mémoire est dans un état utilisable: par exemple, c'est déjà une string.
2. Cette mémoire est de taille connaissable par un moyen explicite quelconque, et la documentation dit lequel
3. Cette mémoire est pourrie, et tu peux a peine supposer que le premier char est présent.

Dans les deux premiers cas, tu peux avoir la taille.
Dans le troisième, tu te contenteras d'accepter que ca ira, et tu documentes que "Comme la taille du buffer n'est pas déterminable dans cette fonction, c'est à l'utilisateur de s'assurer qu'il n'y aura pas de fuite mémoire. Toute erreur à ce sujet permettra une attaque par buffer overflow permettant l'exécution de code arbitraire."

Bon, c'est un designe pourri, et ils ont fait avec.

Alors, faut s'adapter.
Il y a une information supplémentaire, peut-être non écrite, qui n'est pas dans la signature de la fonction.

Comme il y a des crétins pour faire des Dll qui "fonctionnent" avec. Le plus fiable, c'est d'utiliser exactement les mêmes assertions que les autres ont fait.

Ainsi, si ça plante, ça plante pour tout le monde (toutes les Dll).

Je suis bien dans le troisième cas, mais je voulais m'assurer qu'il n'y avait pas quand même une solution à laquelle je n'avais pas pensée.

Je vous remercie tous beacuoup.

Je vais mettre le tag "résolu" car maintenant les choses sont tout à fait claires, merci encore.