C++: convert LPTSTR to char array [duplicate]

Question

This question already has answers here:

Closed 7 years ago.

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.

Answer 1

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*

Answer 2

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.

Answer 3

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