tags:

views:

110

answers:

4

I have a TCHAR and value as below:

TCHAR          szDestPathRoot[MAX_PATH]="String This";

Now I want the 1st three character from TCHAR , like below:

szDestPathRoot.substring(0,2);

How can I do this.

+1  A: 

This is somewhat ugly but if you know for sure that:

  1. The string holds at least 4 TCHAR (3 chars plus the terminating NULL)
  2. The content of the string can be modified (which is the case in your example).
  3. You don't have to keep the original string intact

You could just put a terminating NULL at the 4th position to make the string 3 char long.

szDestPathRoot[3] = _T('\0');

Note that this operation is destructive to the original string

You should really be using a string class in C++ code though.

Alexandre Jasmin
@Alexandre Jasmin , I don't understand how does this substring the szDestPathRoot . I need Str from the above assignment
Subhen
@Subhen: It has a bug (it should be placing the NULL at position 4), but what it does is limit the length of the string to x-1 number of characters. The code places the string ending character (NULL) at position three, and therefore the length of the string in question becomes two.
Billy ONeal
@Billy ONeal s[0]='S'; s[1]='T'; s[2]='R'; s[3]='\0'. I count three chars.
Alexandre Jasmin
@Alexandre: No, the length of the string is 2. It occupies 3 bytes of memory, but the null is not part of the string.
Billy ONeal
@Billy, I think I see why you're confused. That's an assignment statement, not an array declaration.
Mark Ransom
You should note that this is destructive to the original string.
Mark Ransom
@Mark Right. Done
Alexandre Jasmin
@Mark: Oops. I'll get surgury to remove the foot next week :)
Billy ONeal
+3  A: 
TCHAR szDestPathRoot[MAX_PATH]="String This";
TCHAR substringValue[4] = {0};
memcpy(substringValue, szDestPathRoot, sizeof(TCHAR) * 3);
jojaba
@Blindy: memcpy is an ansi c method that takes a const as the second param. How does this destroy the original string?
jojaba
+8  A: 

TCHAR[] is a simple null-terminated array (rather than a C++ class). As a result, there's no ".substring()" method.

TCHAR[] (by definition) can either be a wide character string (Unicode) or a simple char string (ASCII). This means there are wcs and str equivalents for each string function (wcslen() vs strlen(), etc etc). And an agnostic, compile-time TCHAR equivalent that can be either/or.

The TCHAR equivalent of strncpy() is tcsncpy().

Final caveat: to declare a TCHARliteral, it's best to use the _T() macro, as shown in the following snippet:

TCHAR szDestPathRoot[MAX_PATH] = _T("String This");
TCHAR szStrNew[4];
tcsncpy (str_new, szTestPathRoot, 3);

You may find these links to be of interest:

`TCHAR` is not an array type.
dreamlax
+1  A: 

As you have tagged your question with "C++" you can use the string classes of the std library:

std::wstring strDestPathRoot( _T("String This") );
strDestPathRoot.substr( 0, 2 );
Flinsch
I do not want to convert to string
Subhen
Then just use `strncpy` or `strncpy_s`. But, however, why not using std's string classes?
Flinsch
Sorry: `wcsncpy` or `wcsncpy_s` for unicode strings.
Flinsch
Two nitpicks. 1. `std::wstring` is a string of `wchar_t` not `TCHAR`. With `std::wstring` don't use the `_T()` macro just prefix the literal with an `L`. 2. As @user421195 mentioned the `TCHAR` version of `strncpy()` is `tcsncpy()`
Alexandre Jasmin
If you're using `TCHAR`, it should be `std::basic_string<TCHAR>`, not `std::wstring`.
jalf
Oh yeah, you're both right! Thanks and sorry.
Flinsch