Discussion :

[LinuxUser]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[jblecanard]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[LinuxUser]

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.

[ternel]

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.

[LinuxUser]

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é.

[bacelar]

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

[LinuxUser]

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)).

[ternel]

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.

[Bousk]

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 ?

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.

[Ehonn]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[LinuxUser]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
// Code JNI
 
#define SIZE 1000
 
...
 
char str[SIZE]; // str sera fournit à la DLL C++

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
// JNI
#define SIZE 500

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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!

[Ehonn]

Tu peux ajouter une fonction dans la dll ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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.

Donc si tu as une fonction du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

mon problème serait resolu.

[Ehonn]

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).