How do I get a substring of a LPCTSTR? - c++

Question

How do I get a substring of a LPCTSTR?

Answer 1

LPCSTR is just fancy name for char *, it doesn't have methods.
If you use std::string you could use the find and substr methods to extract the first and second part of the string.
Edit: As noted by Christoph, the type of TCHAR differs depending on if UNICODE is defined or not. If UNICODE is defined (check with #ifdef UNICODE, do a Google search on preprocessor to learn more about things like #define and #ifdef) you need to use std::wstring instead of std::string.
Edit 2: An easier solution than checking if you need to use std::string or std::wstring all the time, is to follow the advice of Konrad Rudolph and create a new typedef similar to std::string and std::wstring. Something like this:
typedef std::basic_string<TCHAR> tstring;
And then use that string type internally.

Answer 2

As an alternative, as LPCTSTR is a TCHAR*, then you can "substring" quite easily using _tcschr...depending on what your use case is.
TCHAR* exepath = getTheFullPathToThisProcess();
TCHAR* extension = _tcschr(exepath,'.'); //extension is a valid c-string containing '.exe'
//where is the last "\"?
TCHAR* slash = _tcsrchr(exepath,'\\');
*slash = 0;//exepath is now shortened to the path pre the filename of this process.
Might be easier for you if you are comfortable in c-string land.
EDIT : Forgot that LPCTSTR is a const! You would need to do a _stprintf(copy,"%s",exepath) in that case... so may not be worth it. But will leave this here as an alternative anyway.

Answer 3

Make use of the fact that string is actually a template itself.
typedef std::basic_string<TCHAR, std::char_traits<TCHAR>, std::allocator<TCHAR> > tstring;
Then use
tstring str( _T("Hello world" ) );
tstring sub = str.substr(6, 3 );
Unfortunately there is no tcout unless you #define it somewhere:
#ifdef _UNICODE
#define tcout wcout
#else
#define tcout cout
#endif
Now I can print my string
tcout << sub << static_cast<TCHAR>('\n');
Note that in general code like this gets very messy, and will often lead to enormous bloat.

Answer 4

use _tcsstr() to find a substring in a LPCTSTR
an LPCSTR is either a pointer to an ANSI string ('char') or a unicode string ('wchar')
you don't need to do any conversion to stl:string etc.
just call the appropriate flavor of strstr() which is what _tcsstr() does

Answer 5

This is to convert into std::string -
LPCTSTR astring ="A random string";
std::string temp = astring;
Then use basic_string::find to get position of substrings separator ("-" was before your editing) and basic_string::erase to erase string after this position.
Consult with MSDN for samples: basic_string Members

Answer 6

LPCTSTR is Microsoft specific type and stands for Long Pointer to Constant T (Unicode) STRing. In other words, it is const TCHAR* where TCHAR is generic character (defined in WinNT.h):
#ifdef UNICODE
typedef WCHAR TCHAR
#else
typedef char TCHAR
#endif
where WCHAR is:
typedef wchar_t WCHAR
So, LPCTSTR is pointer and you cannot do much with string it represents unless you want to play with pointers, count bytes and search for zero-termination character. It is better to use some of string abstractions (classes), like MFC or ATL CString, or STL string - std::string which is better as you don't depend on MFC/ATL but just standard C++ library. One catch is that STL has string based on narrow- and wide- characters: std::string and std::wstring. As your code is written for UNICODE, you can do something like this:
#include <string>
#ifdef UNICODE
typedef std::wstring tstring;
#else
typedef std::string tstring;
#endif
int main()
{
// ANSI "te-st" or L"te-st" if UNICODE
TCHAR pszStr[] = TEXT("te-st");
// const char* or const wchar_t* if UNICODE
LPCTSTR pStr = pszStr;
tstring str(pStr);
tstring sub1 = str.substr(str.find(TEXT("-")) + 1);
tstring sub2 = str.substr(0, str.length() - sub1.length() - 1);
// sub1 contains "st" (L"st" if UNICODE) and sub2 contains "te" (L"te" if UNICODE)
return 0;
}

Answer 7

You must copy the string, you can't have a pointer to existing buffer, with null terminator where you need it, without changing the buffer, which you can't because it's const (the C in LPCTSTR).

Answer 8

If you're using MFC, you could also construct a CString and use that to get the second half.
LPCTSTR both = "first-second";
CString bothStr(both);
CString second_half = bothStr.Right(bothStr.GetLength() -
(bothStr.Find("-") + 1));