Concaténer deux LPCWSTR

Version imprimable

14/05/2009, 14h17
melleb

Concaténer deux LPCWSTR

Bonjour,

voilà, en gros, j'ai deux variables de type LPCWSTR
et je voudrais les concaténer en mettant un '.' entre les deux

Comment dois-je faire?

Merci
14/05/2009, 14h22
Invité
2 solutions: soit tu utilises les MFC, et dans ce cas, une utilisation de CStringW peut faciliter la tache, ou alors tu utilises wcscat() (version UNICODE de strcat())

donc soit tu fais :
Code:

1 2 3 4 5 LPWSTR string1 = /*...*/; LPWSTR string2 = /*...*/; CStringW str = string1 + L"." + string2;
soit :
Code:

1 2 3 4 5 WCHAR str[512] = {0}; wcscat(str, string1); wcscat(str, L"."); wcscat(str, string2);

3ème solution : std::wstring : même démarche qu'avec CStringW.
Code:

1 2 3 4 5 6 7 LPWSTR p_str_1=...; LPWSTR p_str_2=...; std::wstring str1(p_str_1); std::wstring str2(p_str_2); std::wstring str_res = str1 + L'.' + str2; // ou std::wstring str_res = std::wstring(p_str_1) + L'.' + p_str_2;
@toxcct : il faut probablement convertir vers un CStringW, sinon c'est addition de pointeur, non :

Code:

CStringW str = CStringW(string1) + L"." + string2;

14/05/2009, 14h58
melleb

Ok, merci

Bon j'ai réussi à concaténer mes deux chaînes dans un wstring
Mais au final, moi je veux un LPCWSTR...

Donc maintenant :

Comment je fais pour convertir un wstring en LPCWSTR ??
14/05/2009, 15h00
Invité

Citation:

Envoyé par melleb

Comment je fais pour convertir un wstring en LPCWSTR ??

la classe std::wstring a une methode qui permet d'avoir ca : c_str()
14/05/2009, 15h01
3DArchi

Citation:

Envoyé par melleb

Ok, merci

Bon j'ai réussi à concaténer mes deux chaînes dans un wstring
Mais au final, moi je veux un LPCWSTR...

Donc maintenant :

Comment je fais pour convertir un wstring en LPCWSTR ??

:faq:
:recherch:
14/05/2009, 15h18
melleb

ousp!
:oops:

merci merci

Es-tu sûr que tu veux vraiment des LPCWSTR, ou ne veux-tu pas plutôt des LPCTSTR ?

Ce code, qui utilise directement des pointeurs pour être utilisable depuis le C, marche aussi bien pour char, wchar_t et TCHAR/_TCHAR :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*Concat.h */
 
#ifndef H_CONCAT_20090514_1518
#define H_CONCAT_20090514_1518
 
#ifndef EXTERN_C
	#ifdef __cplusplus
	#define EXTERN_C extern "C"
	#else
	#define EXTERN_C extern
	#endif
#endif
 
#include <tchar.h>
 
EXTERN_C  char   * ConcatA( char   const* left,  char   const* right);
EXTERN_C wchar_t * ConcatW(wchar_t const* left, wchar_t const* right);
 
EXTERN_C void FreeStringA( char   * del);
EXTERN_C void FreeStringW(wchar_t * del);
 
#ifdef __cplusplus
	/* En C++, on fait des surcharges */
	inline  char   * Concat( char   const* left,  char   const* right) { return ConcatA(left, right); }
	inline wchar_t * Concat(wchar_t const* left, wchar_t const* right) { return ConcatW(left, right); }
#else
	/* En C, on suit le modèle Windows */
 
	/*Note: Ces fonctions n'ont pas d'implémentation réelle*/
	_TCHAR * Concat(_TCHAR const* left, _TCHAR const* right);
	void FreeString(_TCHAR * del);
 
	#ifdef _UNICODE
	#define Concat ConcatW
	#define FreeString FreeStringW
	#else
	#define Concat ConcatA
	#define FreeString FreeStringA
	#endif
 
#endif
 
#endif /* ! H_CONCAT_20090514_1518 */

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/* Concat.h */
#include "Concat.h"
#include <cstring>
#include <cwchar>
#include <new>
using namespace std;
 
EXTERN_C char * ConcatA(char const* left, char const* right)
{
	size_t const leftLength = strlen(left);
	size_t const rightLength = strlen(right);
	size_t const totalLength = leftLength  + rightLength ;
	char * ret = new(nothrow) char[totalLength + 1];
	if(ret != NULL)
	{
		memcpy(ret+0, left, leftLength * sizeof *ret);
		memcpy(ret+leftLength, right, rightLength * sizeof *ret);
	}
	return left;
}
 
EXTERN_C wchar_t * ConcatW(wchar_t const* left, wchar_t const* right)
{
	size_t const leftLength = wcslen(left);
	size_t const rightLength = wcslen(right);
	size_t const totalLength = leftLength  + rightLength ;
	wchar_t * ret = new(nothrow) wchar_t[totalLength + 1];
	if(ret != NULL)
	{
		memcpy(ret+0, left, leftLength * sizeof *ret);
		memcpy(ret+leftLength, right, rightLength * sizeof *ret);
	}
	return left;
}
 
EXTERN_C void FreeStringA(char * del)
{
	delete[] del;
}
EXTERN_C void FreeStringW(wchar_t * del)
{
	delete[] del;
}

14/05/2009, 16h16
white_tentacle
Personne n'a réagi, mais ne SURTOUT PAS faire ça :
Code:

1 2 3 4 WCHAR str[512] = {0}; // PAS BIEN wcscat(str, string1); wcscat(str, L"."); wcscat(str, string2); // et paf, buffer overflow si wcslen(string1) + 2 + wcslen(string2) > 512
C'est de la graine de buffer overflow... Le faire correctement double triple pratiquement le nombre de lignes. Passer par des CString ou des std::wstring est une bonne solution, plus concise qui plus est.
14/05/2009, 16h21
melleb

Citation:

Envoyé par Médinoc

Es-tu sûr que tu veux vraiment des LPCWSTR, ou ne veux-tu pas plutôt des LPCTSTR ?

OUi oui, c'est bien des LPCWSTR
(il s'agit d'une variable d'une structure utilisée pour une dll que j'utilise...
donc pas le choix...)
14/05/2009, 16h25
Médinoc

Dans ce cas, la fonction ConcatW() que j'ai fournie te donnera un LPWSTR, qu'il faudra ensuite libérer avec FreeStringW().

Mais si tu es purement en C++, autant utiliser une classe de chaîne (CStringW si tu es sous MFC >= 7, std::wstring sinon).