C++: convert LPTSTR to char array

Question

Possible Duplicate:
Convert lptstr to char*

I need to convert an LPTSTR p to CHAR ch[]. I am new to C++.

#include "stdafx.h"
#define _WIN32_IE 0x500
#include <shlobj.h>
#include <atlstr.h>
#include <iostream>
#include <Strsafe.h>

using namespace std;

int main(){
    int a;
    string res;
    CString path;
    char ch[MAX_PATH];
    LPTSTR p = path.GetBuffer(MAX_PATH);
    HRESULT hr = SHGetFolderPath(NULL,CSIDL_APPDATA, NULL, SHGFP_TYPE_CURRENT, p);

/* some operation with P and CH */

    if(SUCCEEDED(hr))
    { /* succeeded */
        cout << ch;
    } /* succeeded */
    else
    { /* failed */
        cout << "error";
    } /* failed */
    cin >> a;
    return 0;
}

Thanks in advance.

http://stackoverflow.com/questions/342772/convert-lptstr-to-char — triclosan, May 21 '12 at 09:12

score 6 · Accepted Answer · edited May 23 '17 at 11:45

6

LPTSTR is a (non-const) TCHAR string. Depends if it is Unicode or not it appears. LPTSTR is char* if not Unicode, or w_char* if so.

If you are using non-Unicode strings LPTSTR is just a char*, otherwise do:

size_t size = wcstombs(NULL, p, 0);
char* CharStr = new char[size + 1];
wcstombs( CharStr, p, size + 1 );

Also, this link can help:

Convert lptstr to char*

edited May 23 '17 at 11:45

Community

1
1

answered May 21 '12 at 09:26

Sergey K.

24,894
13
106
174

I have Error 23 error C2664: 'wcstombs' : cannot convert parameter 2 from 'LPTSTR' to 'const wchar_t *' – Oleksandr Fentsyk May 21 '12 at 10:00
You have non-Unicode strings, you don't need to use wcstombs() in this case. Just use a simple cast to char*. – Sergey K. May 21 '12 at 11:38
+1 `LPTSTR is char* if not Unicode, or w_char* if so.` It was a surprisingly long time until I ran across this little bit of clarity. Quick, helpful summary of the same at http://www.kerwal.com/home/charwchartwchartcharomgwtftmi. – Ben Nov 01 '12 at 01:54

score 2 · Answer 2 · edited May 23 '17 at 12:33

2

First, you defined char* ch[MAX_PATH] instead of char ch[MAX_PATH].

Regarding your question, LPTSTR (Long Pointer to TCHAR String) is equivalent to LPWSTR (which is w_char*) if it's unicode, or just LPSTR (char*) if it is not. You can use this link for reference about conversion in each case.

EDIT: To cut to the chase, here's some code:

if (sizeof(TCHAR) == sizeof(char))  // String is non-unicode
    strcpy(ch, (char*)(p));       
else                                // String is unicode
    wcstombs(ch, p, MAX_PATH);

EDIT 2: In windows I would recommend using TCHAR instead of char. It will save you some headache.

EDIT 3: As a side note, if you want to prevent Visual Studio from flooding you with warnings about unsafe functions, you can add something like the following to the very beginning of your code:

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

edited May 23 '17 at 12:33

Community

1
1

answered May 21 '12 at 09:14

Eitan T

32,660
14
72
109

Can you write some code? – Oleksandr Fentsyk May 21 '12 at 10:09
@Sasha the reference I gave you should have covered it, but sure. I added sample code to the answer. – Eitan T May 21 '12 at 11:16
1

I think ATL conversion helpers make the code easier. Moreover, if you want to do a check for Unicode vs. ANSI/MBCS builds, I'd prefer checking with the preprocessor _at compile-time_ with `UNICODE/_UNICODE` preprocessor macros (which are `#define`'d in Unicode builds), instead of checking at run-time with `if(sizeof(TCHAR) == sizeof(char)) ...`. – May 21 '12 at 11:25
+1 for compile-time checking :) – Eitan T May 21 '12 at 11:26
Its usually best to try if the secure template overloads (http://msdn.microsoft.com/en-us/library/ms175759%28v=vs.100%29.aspx) silence enough warnings, instead of disabling the warnings altogether. After all there is a reason why these warnings exist. – smerlin May 21 '12 at 12:41

score 2 · Answer 3 · 2012-05-21T10:56:42.903

LPTSTR means TCHAR* (expanding those Win32 acronyms typedefs can make it easier to understand them). TCHAR expands to char in ANSI/MBCS builds, and to wchar_t in Unicode builds (which should be the default in these days for better internationalization support).

This table summarizes the TCHAR expansions in ANSI/MBCS and Unicode builds:

          |   ANSI/MBCS    |     Unicode
  --------+----------------+-----------------
  TCHAR   |     char       |     wchar_t
  LPTSTR  |     char*      |     wchar_t*
  LPCTSTR |  const char*   |  const wchar_t*

So, in ANSI/MBCS builds, LPTSTR expands to char*; in Unicode builds it expands to wchar_t*.

char ch[MAX_PATH] is an array of char's in both ANSI and Unicode builds.

If you want to convert from a TCHAR string (LPTSTR) to an ANSI/MBCS string (char-based), you can use ATL string conversion helpers, e.g.:

LPTSTR psz;   // TCHAR* pointing to something valid    
CT2A ch(psz); // convert from TCHAR string to char string

(Note also that in your original code you should call CString::ReleaseBuffer() which is the symmetric of CString::GetBuffer().)

Sample code follows:

// Include ATL headers to use string conversion helpers
#include <atlbase.h>
#include <atlconv.h>
...

LPTSTR psz = path.GetBuffer(MAX_PATH);
HRESULT hr = SHGetFolderPath(NULL,CSIDL_APPDATA, NULL, SHGFP_TYPE_CURRENT, psz);
path.ReleaseBuffer();
if (FAILED(hr))
{
  // handle error
  ...
}

// Convert from TCHAR string (CString path) to char string.
CT2A ch(path);

// Use ch...
cout << static_cast<const char*>(ch) << endl;

Note also that the conversion from Unicode to ANSI can be lossy.

C++: convert LPTSTR to char array

3 Answers3