Struggle adding LPSTR and string into LPCTSTR

Question

I'm new to strings on C++, I'm since hours on this, I've been on lots of forums so I understand what kind of char* are LPSTR, LPCSTR or LPCSTR, but I can't find a way and understand how to build a string with them.

My intend is to use GetCurrentDirectoryA and CopyFileA to copy/paste a file in a new one.

Here is my code :

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <windows.h>
#include <winbase.h>


using namespace std;


#define DR drum-
#define NO normal-
#define SO soft-


//main
int main(){
LPCTSTR input;
LPCTSTR output;
LPSTR cd;
LPCSTR src = "source.wav";



if(GetCurrentDirectoryA(strlen(cd), cd)){
    input =  (LPCTSTR)cd + (LPCTSTR)src;


    if(CopyFileA(input, cd + "DR" + "hitclap.wav"))
        cout<<"done"<<endl;
    else
        cout<<"error"<<endl;
}
}

Please read some books (a const char* adds badly to another const char*) — , Nov 20 '15 at 19:54
You are mixing `LPCSTR` with `LPCTSTR`; if you want to use the `A` variants of the API just use `LPSTR` and `LPCSTR`. — MicroVirus, Nov 20 '15 at 19:56
if the program is built as unicode, then it matters. If he is building an ascii, TCHAR == char, and it doesnot matter — Nandu, Nov 20 '15 at 20:02
@Nandu consistency is a good thing whether it matters or not. The A variants of the API functions are meant to work with `char*` strings only, so if you're explicit about the one you should be explicit about the other. — Mark Ransom, Nov 20 '15 at 20:15
agreed with your argument. But, being inconsistent does not mean incorrect always, as it is in the OP's case — Nandu, Nov 20 '15 at 20:17
To add strings together, either use `std::string`/`std::wstring`, which support `s+t`, or allocate a buffer and use `snprintf()`/`strncat()`. Adding pointers together in C is a trap that only compiles for historical reasons; you might sometimes want to add the *difference* of two pointers to a pointer, as in `base + (p - a)`, but adding C pointers to each other is always shooting yourself in the foot. — Davislor, Nov 20 '15 at 21:20
avoid using TCHAR or any of the TCHAR-using function. It just complicates your code for no reason. Unless you literally want your code to work on Windows 95. — M.M, Nov 21 '15 at 03:27
Avoid using `GetCurrentDirectoryA()`. It does not support `UNICODE`. Nowadays it is a MUST to use `GetCurrentDirectoryW() ` — Andrew Komiagin, Nov 21 '15 at 18:32

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

The API GetCurrentDirectory doesn't return a new string to you. What it does is you pass it a memory location and it fills that memory location for you with the current directory string.

The problem is you haven't allocated memory, you pass it an uninitialised char* (LPSTR), cd. You also use strlen on this uninitialised character pointer. Typically, you use a character array with length MAX_PATH for playing with filenames:

char cd[MAX_PATH];

GetCurrentDirectoryA(sizeof(cd), cd);

A second note is that you cannot use the + operator to concatenate C strings. Either you go the C route and use strcat[1] and friends, or you go the C++ route and replace all your char*s with std::string and work with that.

Choose one of the two roads and then go and read a tutorial on either char*-strings in C or std::string in C++.

To properly understand the LPTSTR type and its relation to LPSTR, please see this question & answer I created.

[1] How do I concatenate const/literal strings in C?

score 1 · Answer 2 · answered Nov 20 '15 at 20:07

Signature of GetCurrentDirectory is

DWORD WINAPI GetCurrentDirectory(
  _In_  DWORD  nBufferLength,
  _Out_ LPTSTR lpBuffer
);

lpBuffer is the pointer to memory buffer where contents should be placed, and nBufferLength is the size of this memory region in TCHARs.

so the correct code would be:

TCHAR szBuffer[MAX_PATH];
GetCurrentDirectory(MAX_PATH, szBuffer);

you must use TCHAR as for non unicode build it will resolve to char, and for unicode it will be wchar_t.

score 1 · Answer 3 · answered Nov 20 '15 at 20:07

Welcome to the legacy of the 80286 memory model and the evolution from 8-bit characters to (sort of) unicode used by the Windows OS.

LPCSTR means: "long pointer to const string" and today is equivalent to const char*. Not too many years ago it was equivalent to const char* far - far being a Microsoft extension that told the compiler that the address could be in a different memory segment (if you really care, google is your friend "segmented memory model 80286")

LPCTSTR means: long pointer to const [either wide or 8-bit, depending on compiler flags] character. e.g. either: const char* or const wchar_t* depending on the build mode.

similarly LPSTR is char * today but once upon a time was char * far.

So you can see that the Windows API is actually using raw pointers to c-style strings, which are either const or mutable, and either wide chars or 8-bit chars depending on context and build options.

score 1 · Answer 4 · answered Nov 20 '15 at 21:01

Using Boost Filesystem¹ you'd write:

Live On Coliru

#include <boost/filesystem.hpp>
#include <iostream>

#define dr "drum -"
#define no "normal -"
#define so "soft -"

int main() {
    using boost::filesystem::path;

    auto input  = absolute(path("source.wav"));
    auto output = absolute(path(dr "hitclap.wav"));

    std::cout << input << " " << output << "\n";
}

Printing

"/tmp/1448053072-1243850518/source.wav" "/tmp/1448053072-1243850518/drum -hitclap.wav"

You can take it from there.

¹ Note: Microsoft Visual C++ ships a version of <filesystem> since... VS2010 even I think. So you might not need boost at all to enjoy the lush life :)

otah007 · Answer 5 · 2015-11-20T20:15:58.480

0

Whenever I use something that takes or uses LPSTR/LPCTSTR, I tend to use an std::wstring instead:

std::wstring input = _T("");
input.append(_T("Sample Text"));
input.append(std::to_wstring(myint));
std::copy(mystring.begin(), mystring.end(), text.end());

This makes it possible to use a string in place of an LPCTSTR. I don't know if it will work in this case, but I think it will.

EDIT: As @MicroVirus said, you should really go all the way and use TCHAR for everything, that way your program is compatible with both ANSI and Unicode (your functions use ANSI, as denoted by the trailing 'A').

edited Nov 20 '15 at 20:15

answered Nov 20 '15 at 20:02

otah007

505
1
4
17

`wstring` only works with `wchar_t`, that is if character set is set to Unicode. OP specifically requested for the ANSI versions of the APIs. – MicroVirus Nov 20 '15 at 20:03
@MicroVirus In which case I assume you can use a regular string? If so I will update my answer. However is there really any reason to use ANSI anyway? – otah007 Nov 20 '15 at 20:09
Let me put it this way: you can either go the full way of supporting `TCHAR`, or you can settle on using one of the two character encodings (either `char` or `wchar_t`) and stick to that. For new programs, you should actually just use `wchar_t` and Unicode and not bother with `TCHAR` or the `_T(..)` macro, but it requires you to set the compiler options correctly **and** use `wchar_t` everywhere and not mix. – MicroVirus Nov 20 '15 at 20:12
okay im gonna switch to unicode and try for your solution then, thanks a lot – Georges Nov 20 '15 at 20:14

Davislor · Answer 6 · 2015-11-21T03:10:33.240

You can use the following to use the <string> STL library with the Windows W API:

#include <cassert>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>

#include <windows.h>

using std::endl;
using std::cout;
using std::cerr;

using tstring = std::basic_string<TCHAR>;

const std::wstring dr = L"drum-";
// OR: const tstring dr = TEXT("drum-");
const std::wstring no = L"normal-";
const std::wstring so = L"soft-";
const std::wstring src = L"drum.wav";
const std::wstring dest = L"hitclap.wav";

int main()
{
   const std::vector<wchar_t>::size_type cd_buf_len = GetCurrentDirectoryW( 0, NULL );
   assert( cd_buf_len > 0 );
   std::vector<wchar_t> cwd( cd_buf_len, 0 );
   const DWORD cd_result = GetCurrentDirectoryW( cd_buf_len, cwd.data() );
   assert(cd_result);

   if (CopyFileW( (cwd.data() + src).c_str(), (cwd.data() + dr + dest).c_str(), FALSE )) {
       cout << "Done." << endl;
   } else {
       cerr << "Error." << endl;
       return EXIT_FAILURE;
   }

   return EXIT_SUCCESS;
}

This version is fixed to correct a bug in the initial post: modifying a .c_str() causes undefined behavior. It’s conceptually simple and uses addition as requested, but is not as efficient as it would be to allocate buffers and copy the source strings to them, or to use +=. You might therefore really want to write:

constexpr wchar_t src[] = L"drum.wav";
/* … */
std::wstring src_path = cwd.data();
src_path += src;

To use the TCHAR versions, change wchar_t to TCHAR, change L"foo" to TEXT("foo"), change std::wstring to tstring, change LPWSTR to LPTSTR, change GetCurrentDirectoryW to GetCurrentDirectory, etc.

You do not, generally, want to mix 8-bit and wide strings in the same program unless you explicitly need to input in one encoding and output in the other. If so, you must explicitly convert, such as by setting the current code page to 65001 (UTF-8) and using std::wstring_convert.

Struggle adding LPSTR and string into LPCTSTR

6 Answers6