Concaténer des LPCSTR et un char

Bonjour,

je n'arrive pas à trouver comment concaténer deux LPCSTR avec un caractère entre les deux.

Le but est d'appeler une fonction d'une manière similaire à celle-ci :

Code:

---

1 2	Toggle(1, 2, 3, 4, 5, 6, "texte1""\xff""texte2");

---

Si j'appelle la méthode de cette manière, alors tout fonctionne bien.

Maintenant, je reçois les paramètres via une methode qui a cette signature :

Code:

---

1 2	void SourceToggle( INT32 param0, INT32 param1, INT32 param2, INT32 param3, INT32 param4, INT32 param5, LPCSTR param6, LPCSTR param7, HRESULT &hr )

---

et je dois concaténer param6 et param7 en insérant "\xff" entre les deux pour ensuite appeler la méthode "Toggle" qui a la signature suivante :

Code:

---

1 2	void Toggle(int param0, int param1, int param2, int param3, int param4, int param5, const unsigned char* message)

---

Ce qui donnerait le pseudo-code suivant :

Code:

---

1 2 3 4 5

void SourceToggle( INT32 param0, INT32 param1, INT32 param2, INT32 param3, INT32 param4, INT32 param5, LPCSTR param6, LPCSTR param7, HRESULT &hr ) { Toggle(param0, param1, param2, param3, param4, param5, param6 + "\xff" + param7); }

---

Malheureusement, ça ne fonctionne évidemment pas et je suis complètement perdu entre les LPCSTR, char * et autres joyeusetés :(
Sachant qu'en plus je ne peux pas utiliser la fonction strcpy car le compilateur me signale une erreur de type "Do not use".

Pour information, la fonction de haut niveau provient de code managé en C# et tout se passe sur des cartes embarqués en .NET MicroFramework.


Donc, finalement, mon message pourrait se résumer à : AU SECOURS !!! :oops:

Pseudo Code: :mrgreen:

1) Trouver la longueur en octets de param6
2) Trouver la longueur en octets de param7
3) Allouer une nouvelle chaîne de taille (taille de param6 + taille de param 7 + 1 + 1)
1 pour "\xff".
1 pour '\0' final.

4) Copier dans cette nouvelle chaîne param6, puis "\xff", puis param7
Si la fonction strcpy n'est pas disponible, soit une boucle for soit la fonction memcpy soit une autre fonction.
Mais en raisonnant en octets

5) Ne pas oublier le '\0' final

En clair, tu cherches une bête concaténation de chaîne, vu que LPCSTR est symplement un typedef sur const char*...

Fais-toi une fonction char* concat_trois_chaines(const char *chn1, const char *chn2, const char *chn3) et réfléchis à comment l'implémenter...

PS: Micro$oft cherche à interdire strcpy() pour leur solution "plus sécurisée" propriétaire strcpy_s(). Tu peux l'envoyer ch*** avec un #define _CRT_SECURE_NO_WARNINGS si tu cherches à écrire un code portable, mais si tu codes juste pour Windows il est plus simple et plus prudent d'utiliser strcpy_s() dans le cas présent.

Merci pour vos réponses !

Ceci dit, je suis en train de me demander comment dire que j'ai l'air bête sans l'écrire... Ah mince ! Trop tard :oops:

;)

Voici le code qui fonctionne :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void ManagedToggle( INT32 param0, INT32 param1, INT32 param2, INT32 param3, INT32 param4, INT32 param5, LPCSTR param6, LPCSTR param7, HRESULT &hr ) { char strtmp[50] = "";   strcat(strtmp,param6); strcat(strtmp,"\xff"); strcat(strtmp,param7); NativeToggle(param0, param1, param2, param3, param4, param5, (const unsigned char*)strtmp); strtmp[0]='\0'; }

---

Il est plutôt simple et je me demande encore comment j'ai pu passer à côté aussi longtemps !? Je me fourvoyais avec des LPCSTR, des casts et autres alors que ça paraît simple finalement.
Le contrôle de la longueur de param6 et param7 est fait en amont, avant l'appel de la méthode managée. C'est pour ça que je ne teste pas ici.


Maintenant, mais là plus pour le côté intellectuel de la chose, le code suivant ne fonctionne pas, lui :(

Code:

---

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

void ManagedToggle( INT32 param0, INT32 param1, INT32 param2, INT32 param3, INT32 param4, INT32 param5, LPCSTR param6, LPCSTR param7, HRESULT &hr ) { char * strtmp = new char[50]();   strcat(strtmp,param6); strcat(strtmp,"\xff"); strcat(strtmp,param7); NativeToggle(param0, param1, param2, param3, param4, param5, (const unsigned char*)strtmp);   delete strtmp; }

---

Sous Visual Studio, cela fonctionne, si ce n'est que le caractère \xff est représenté par un "y" tréma.
Par contre, une fois sur un STM32F4, ça me plante le processeur. Carrément.

Auriez-vous une idée du pourquoi ça ne marche pas ? Je penche de mon côté pour une différence de gestion de new/delete mais bon, ça reste des instructions standard, non ? Donc ça doit être autre chose qui m'échappe.

Citation:

---

Envoyé par Médinoc

PS: Micro$oft cherche à interdire strcpy() pour leur solution "plus sécurisée" propriétaire strcpy_s(). Tu peux l'envoyer ch*** avec un #define _CRT_SECURE_NO_WARNINGS si tu cherches à écrire un code portable, mais si tu codes juste pour Windows il est plus simple et plus prudent d'utiliser strcpy_s() dans le cas présent.

---

Dans mon cas, le #define n'a aucun effet et j'ai toujours l'erreur. Comme dit dans mon premier message, peut-être pas assez clairement, je programme sur des cartes STM32F4x, pas sur un PC. Du coup, je n'ai pas forcément les mêmes outils.
En plus, il y a une partie en C# (code managé, donc) et une partie en C/C++ native.

En ce qui concerne strcpy, je pense que la limitation est peut-être dûe au fait que c'est .NET certes, mais MicroFramework, et qu'il y a certainement des limitations liées à la mémoire. Par exemple.

OK.

D'un autre côté, il y a quand même des trucs bizarres:

Pourquoi ta fonction ManagedToggle() prend-elle une chaîne native en paramètre, et pourquoi la chaîne acceptée par NativeToggle() est-elle faite de unsigned chars?

Pour faire rapide, je dirais que je suis "le cul entre deux chaises"...

D'un côté il y a Visual Studio qui me génère des stubs depuis des prototypes managés, avec les paramètres String qui deviennent des LPCSTR, sans que j'ai spécialement mon mot à dire. Mais que pourrais-je dire, en fait ?

Et d'un autre côté, je dois appeler une méthode d'une lib qui ne m'appartient pas, laquelle prend donc ce paramètre en unsigned char *. J'imagine cependant que le unsigned char est là pour pouvoir gérer correctement le "\xff".

Mon code se situe donc à l'interface des deux et est curieusement nommé "driver" dans le système NETMF.
C'est la première fois que j'utilise une lib externe pour accéder aux ressources matérielles (un FTDI FT800, en l'occurence). D'habitude, je suis le dernier maillon de la chaine et j'accède au matériel directement. Je n'ai donc pas ce souci de chaines de caractères puisque j'envoie principalement des unsigned char (bytes).

Le compilateur C est Keil, pour info.

Voili voilou.


Edit:

Pour te situer ce que je fais : http://www.mikrobusnet.org/project/quail-mainboard
Et le résultat pour le FTDI FT800 : http://mikrobusnet.org/bb/index.php/topic,322.0.html

Le code natif (C/C++) est destiné au "firmware" de la carte Quail et le code managé (C# ou VB.Net) est là pour faire le lien avec la partie .NET MicroFramework qui est utilisée pour programmer les applications qui tourneront sur la carte.

Ah OK, je commence à peu près à comprendre.