Passer un char** par référence

Bonjour,

J'essaie en ce moment d'écrire une DLL pour faire divers tests - notamment sur le passage d'arguments par référence. Sur des valeurs numériques, ca fonctionne parfaitement:

Code:

---

1 2 3 4 5 6

extern "C" int __stdcall fonctionDivision (float& dz1, float& dz2) { dz1 = dz1/2; dz2 = dz2/2; RETURN 1, }

---

les changements appliqués à dz1 et dz2 sont bien passés à la variable utilisé comme argument.

J'ai commencé à avoir mon premier problème avec un char*... Du moins jusqu'à ce que je réalise qu'il ma fallait utiliser strcpy(); pour que les chqngements sur l'argument soient pris en compte lors de l'appel de la fonction.

Code:

---

1 2 3 4 5

extern "C" int __stdcall HelloWorld (char* Hello) { strcpy(Hello, "HelloWorld"); return 1; }

---

Jusqu'ici tout va bien.

Les vrais soucis commencent depuis que j'essaie de passer un char**.

Code:

---

1 2 3 4 5 6 7 8 9 10

extern "C" int __stdcall StringArray (char** Array) { char* temp[5]; temp[0] = "Demo Tool"; temp[1] = " "; temp[2] = "v1"; temp[3] = "r2.504"; Array = temp; return 1; }

---

Bien entendu, dans le code ci-dessus, aucun changement n'est pris en compte et si je lis la variable donnée en argument après l'appel de la fonction, elle est identique à son état précédent cet appel. Strcpy ne fonctionne pas non plus. J'ai essayé strcpy(*Array, temp[0]); mais je me retrouve avec une chaine aléatoire de caractères en sortie.

Quekqu'un squrqit-il m'expliquer comment construire mq fonction pour que la valeur char** Array soit passée à la variable utilisée pour l'appel de la fonction?

Merci d'avance :ccool:

Je crois que tu as compris que temp est déclaré localement, donc une affectation Array = temp ne marche que lorsque tu es dans la fonction. Vu que temp est déclaré localement, donc dans la pile de la fonction, lorsque tu sors de celle-ci, la pile "disparait" et donc les données à l'ancienne adresse de temp ne sont plus viables.

Par contre, ton souci strcpy me surprend.

Comment déclares-tu ton char** Array avant l'appel de la fonction ?
Est ce un tableau statique char Array[][] ? Ne déclares-tu pas un tableau trop petit ?

Ou est il déclaré comme un char ** ? Alloues-tu suffisamment de mémoire avec malloc ?

@mala952: oui, j'ai bien compris le fait que la déclaration locale de temp fait que celui ci disparrait apres l'appel de la fonction. J'ai juste laissé Array = temp; dans l'exemple pour illustrer le fait que je cherche à passer le contenu de temps dans Array. Toutefois, merci d'avoir pris la peine de re-clarifier ce point :ccool:

Citation:

---

Envoyé par DeathMixer

Comment déclares-tu ton char** Array avent l'appel de la fonction ?
Est ce un tableau statique char Array[][] ? Ne déclare-stu pas un tableau trop petit ?

Ou est il déclaré comme un char ** ? Alloues-tu suffisamment de mémoire avec malloc ?

---

DeathMixer: J'appelle la fonction depuis LabVIEW, ce qui rend la déclaration un peu différente. Je décrale un tableau de U8 (unsigned 8 bit integer) de 200 élément (ou 4*50, les deux donnant le même résultat). Je récupère ensuis de tableau de U8 que je trqduis en cqrqctères ASCII. Ca fonctionne sans souci avec ma fonction HelloWorld(); . Lá, que mon tqblequ qit une ou deux dimensions, le résultat est aux fraises.

J'ai aussi fait quelques tqtonnements (qllouer un espqce mémoire pour Array dans la fonction (char ** Array = (char**)malloc(200)) et employer la methode brutale (memmove(Array, temp, 200);) mais je me trouve quand même avec une chaine de caractère étrange en sortie("lUÝjhUÝjdUÝj\") qui me fqit pensé qu'il me retrourne juste des adresses mémoires (3*32bits).

J'ai aussi essayé strcpy(Array[0], temp[0]); mais quelque soit l'adresse mémoire alloué, il me renvoi une erreur de mémoire insuffisante.

Bref, je tâtonne. Il est aussi possible que l'erreur vienne de mon appel sous labVIEW, j'explore les deux pistes en parallèle. Cependant, je pense qu'une fois que je suis sûr qure mq fonction est bien écrite en C, il est plus simple de me concentrer sur l'appel de ladite fonction.

Merci à vous deux :ccool:

Tu as alloué un tableau de pointeurs de 200 pointeurs.
Ton souci c'est que tu n'as pas alloué la zone mémoire de ces 200 pointeurs.
Ex :

Code:

---

1 2 3 4

char **p; p = (char**)malloc(10); for(int i = 0; i < 10; i++) p[i] = (char*)malloc(100);

---

L'exemple d'allocation que tu as mis est complètement faux !

Citation:

---

Code:

---

char ** Array = (char**)malloc(200)

---

---

Dans une telle déclaration, tu déclares Array comme un tableau à deux dimensions, autrement dit un pointeur de pointeurs vers des caractères.
Alors que l'allocation que tu fais, alloues 200 octets, mais va considérer ces 200 octets comme un tableau de pointeurs !!! Si tu es sur une machine 32 bits, les pointeurs seront sur 4 octets, donc en faisant Array[0], tu vas récupérer les 4 premiers octets qui vont former une adresse, qui sera très certainement indéterminée !!

Pour allouer correctement un tableau à deux dimensions, il faut faire comme suit:

Code:

---

1 2 3 4

char ** Array = (char **) malloc(4 * sizeof(char*)); for (int i = 0; i < 4; i++){ Array[i] = (char*) malloc(50 * sizeof(char)); }

---

De cette manière tu déclareras un tableau à deux dimensions de taille 4*50.

Autrement dit, tu déclareras un tableau de 4 chaines de caractères, de 50 caractères chacune...

Ach sooooooooooo.

J'essaie ca de suite et vous tient au courrant, mais ca pourrait expliquer beaucoup de chose :oops:

- Ceci n'est pas du C : il n'y a pas de référence en C

-

Citation:

---

J'ai juste laissé Array = temp;

---

1- cela ne copie pas le tableau temp mais ne fait que modifier la variable locale Array
2- et faire *Array = temp reviendrait à renvoyer l'adresse d'une variable locale ce qui est dans tous les cas une erreur

-

Citation:

---

Je décrale un tableau de U8 (unsigned 8 bit integer) de 200 élément (ou 4*50, les deux donnant le même résultat).

---

Dans ce cas, le type du paramètre ne peut pas être char**, mais U8* (ou U8 (*)[50] pour 4*50)

-

Citation:

---

employer la methode brutale (memmove(Array, temp, 200) mais je me trouve quand même avec une chaine de caractère étrange en sortie("lUÝjhUÝjdUÝj\") qui me fqit pensé qu'il me retrourne juste des adresses mémoires (3*32bits).

---

C'est normal, temp est un tableau d'adresses et tu copies ces adresses

-

Citation:

---

J'ai aussi essayé strcpy(Array[0], temp[0]); mais quelque soit l'adresse mémoire alloué, il me renvoi une erreur de mémoire insuffisante.

---

Là, tu copies bien la première chaine mais où ? à l'adresse contenue dans Array[0] et on revient à : comment as-tu déclaré et créé la variable utilisée lors de l'appel ?

Tout ça est trop brouillon. La première chose à faire est de préciser l'interface et le fonctionnement de la fonction : je communique à la fonction quelles informations précisément (type des arguments, comment les arguments seront-ils créés ?), ce qu'elle fait et ce qu'elle renvoie.

Citation:

---

Ton souci c'est que tu n'as pas alloué la zone mémoire de ces 200 pointeurs.
Ex :

Code:

---

1 2 3 4 5 6

char **p; p = (char**)malloc(10); for(int i = 0; i < 10; i++) p[i] = (char*)malloc(100);

---

---

Attention !! Tu alloues 10 octets pour ton char** p !! Et non la mémoire nécessaire pour 10 pointeurs !! Pour ce faire, il faut écrire:

Code:

---

1 2 3

char ** p = (char **) malloc(10 * sizeof(char *)); //...

---

Citation:

---

Envoyé par diogene

-
1- cela ne copie pas le tableau temp mais ne fait que modifier la variable locale Array
2- et faire *Array = temp reviendrait à renvoyer l'adresse d'une variable locale ce qui est dans tous les cas une erreur

---

Ce point est clair depuis le début. Mais merci de la précision.

Citation:

---

Envoyé par diogene

- Dans ce cas, le type du paramètre ne peut pas être char**, mais U8* (ou U8 (*)[50] pour 4*50)

---

Mon but est d'étudier l'utilisation de char** sous labVIEW. C'est pour ca que je souhaite avoir une fonction simple dans un DLL. Ce que la fonction fait n'a en soit pas beaucoup d'importance, mais il est important que je m'assure qu'elle est correctement programmée avant de chercher un moyen de l'utiliser sous labVIEW. En l'état, je ne sais pas si l'erreur viens de ma programmation en C ou de mon appel sous LabVIEW. A partir du moment où il est admis que la fonction "devrait fonctionner", je laisse le C de coté pour me concentrer sur l'appel sous LabVIEW.

Citation:

---

Envoyé par diogene

C'est normal, temp est un tableau d'adresses et tu copies ces adresses

---

Merci, je n'avais pas compris cette fonction de cette manière.

Citation:

---

Envoyé par diogene

Là, tu copies bien la première chaine mais où ? à l'adresse contenue dans Array[0] et on revient à : comment as-tu déclaré et créé la variable utilisée lors de l'appel ?

---

Je réserve un tableau de 4*50 octets qui sont compris par la DLL comme des caracteres ASCII.

Citation:

---

Envoyé par diogene

Tout ça est trop brouillon. La première chose à faire est de préciser l'interface et le fonctionnement de la fonction : je communique à la fonction quelles informations précisément (type des arguments, comment les arguments seront-ils créés ?), ce qu'elle fait et ce qu'elle renvoie.

---

L'idée est de communiquer un char** (peu importe qu'il soit vide ou plein) et que la DLL en change la valeur (dans mon essai, je donne en argument 4*50 espaces et attend en sortie au moins la chaine de caractére "Demo Tool".

Comme dit précédement, j'etudie l'appel de fonctions utilisant char** comme argument sous labVIEW. Ce que la fonction fait m'est - au final - égal. Ecrire 4 chaines de caractéres me semblait etre une fonction suffisemment simple pour mon test.

Citation:

---

Envoyé par DeathMixer

Attention !! Tu alloues 10 octets pour ton char** p !! Et non la mémoire nécessaire pour 10 pointeurs !! Pour ce faire, il faut écrire:

Code:

---

1 2 3

char ** p = (char **) malloc(10 * sizeof(char *)); //...

---

---

Oui, désolé, j'ai fait mon test comme un porc. :oops:

Bonjour,

pourquoi ne pas réutiliser ce qui est déjà fait avec HelloWorld ?

Code:

---

1 2 3 4 5 6 7 8

extern "C" int __stdcall StringArray (char** Array) { strcpy(Array[0], "Demo Tool"); strcpy(Array[1], " "); strcpy(Array[2], "v1"); strcpy(Array[3], "r2.504"); return 1; }

---

Sous réserve que Array soit correctement initialisé (au niveau espace/longueur des chaînes en particulier)

Citation:

---

L'idée est de communiquer un char** (peu importe qu'il soit vide ou plein) et que la DLL en change la valeur (dans mon essai, je donne en argument 4*50 espaces et attend en sortie au moins la chaine de caractére "Demo Tool".

---

Mais, il y a des conditions à remplir parce que 4*50 espaces n'est pas un char**.
Un char** concerne un tableau de pointeurs sur char, pas un tableau de (4) tableaux de (50) char.

Citation:

---

Comme dit précédement, j'etudie l'appel de fonctions utilisant char** comme argument sous labVIEW. Ce que la fonction fait m'est - au final - égal. Ecrire 4 chaines de caractéres me semblait etre une fonction suffisemment simple pour mon test.

---

Oui, mais encore faut-il que le test soit cohérent.
Ecrire 4 chaines de caractères : qui a créé la place pour écrire ces chaines ? La fonction ou bien cet espace était déjà créé ?
Supposons que ce soit le dernier cas : cet espace est créé comme un tableau de char :char table[4][50];.
On ne peut pas passer table comme argument de type char ** (il faudrait que le paramètre soit de type char (*)[50])
Si on veut un paramètre char**, on a donc besoin d'un tableau de pointeurs : char * ptab[4];.
Chaque pointeur doit avoir l'adresse de départ de chaque chaine :

Code:

---

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

char table[4][50]; char * ptab[4]; int i; for(i=0;i<4;i++) ptab[i] = table[i]; StringArray(ptab); .... int StringArray (char** Array) { strcpy(Array[0], "Demo Tool"); strcpy(Array[1], " "); strcpy(Array[2], "v1"); strcpy(Array[3], "r2.504"); return 1; }

---

Ok, merci à tous. Je pense qu'a partir de là je devrais arriver a me debrouiller seul.

Encore merci à diogene pour ses explications détaillées.