调用c_str()以从一个std::string获取一个const char *（LPCSTR）。
一切都在名义上：
LPSTR-指向字符串char *的（长）指针
LPCSTR-指向常量字符串的（长）指针-const char *
LPWSTR-指向Unicode（宽）字符串的（长）指针-wchar_t *
LPCWSTR-指向常量Unicode（宽）字符串const wchar_t *的（长）指针
LPTSTR-指向TCHAR（如果定义了UNICODE，则为Unicode;如果未定义，则为ANSI）字符串的（长）指针-TCHAR *
LPCTSTR-指向常量TCHAR字符串const TCHAR *的（长）指针
您可以忽略名称的L（long）部分--它是16位Windows的遗留部分。

str.c_str()给你一个const char *，它是一个LPCSTR（常量字符串的长指针）--意味着它是一个指向以0结尾的字符串的指针。W意味着宽字符串（由wchar_t而不是char组成）。

这些是Microsoft定义的typedef，对应于：
LPCSTR：指向char的空终止常量字符串的指针
LPSTR：指向char的空终止字符串的指针（通常传递缓冲区并用作"输出"参数）
LPCWSTR：指向常量wchar_t的空终止字符串的指针
LPWSTR：指向wchar_t的空终止字符串的指针（通常传递缓冲区并用作"输出"参数）
将std::string "转换"为LPCSTR取决于确切的上下文，但通常调用.c_str()就足够了。
这个管用。

void TakesString(LPCSTR param);

void f(const std::string& param)
{
    TakesString(param.c_str());
}

请注意，您不应该尝试这样做。

LPCSTR GetString()
{
    std::string tmp("temporary");
    return tmp.c_str();
}

.c_str()返回的缓冲区归std::string示例所有，并且只有在下次修改或销毁字符串之前才有效。
将std::string转换为LPWSTR要复杂得多。要使用LPWSTR意味着需要一个可修改的缓冲区，并且还需要确保了解std::string使用的是什么 * 字符编码 *。如果std::string包含使用系统默认编码的字符串（这里假设是windows），那么您可以找到所需的宽字符缓冲区的长度，并使用MultiByteToWideChar（一个Win32 API函数）执行转码。
例如：

void f(const std:string& instr)
{
    // Assumes std::string is encoded in the current Windows ANSI codepage
    int bufferlen = ::MultiByteToWideChar(CP_ACP, 0, instr.c_str(), instr.size(), NULL, 0);

    if (bufferlen == 0)
    {
        // Something went wrong. Perhaps, check GetLastError() and log.
        return;
    }

    // Allocate new LPWSTR - must deallocate it later
    LPWSTR widestr = new WCHAR[bufferlen + 1];

    ::MultiByteToWideChar(CP_ACP, 0, instr.c_str(), instr.size(), widestr, bufferlen);

    // Ensure wide string is null terminated
    widestr[bufferlen] = 0;

    // Do something with widestr

    delete[] widestr;
}

使用LPWSTR你可以改变字符串所指向的内容。使用LPCWSTR你不能改变字符串所指向的内容。

std::string s = SOME_STRING;
// get temporary LPSTR (not really safe)
LPSTR pst = &s[0];
// get temporary LPCSTR (pretty safe)
LPCSTR pcstr = s.c_str();
// convert to std::wstring
std::wstring ws; 
ws.assign( s.begin(), s.end() );
// get temporary LPWSTR (not really safe)
LPWSTR pwst = &ws[0];
// get temporary LPCWSTR (pretty safe)
LPCWSTR pcwstr = ws.c_str();

LPWSTR只是一个指向原始字符串的指针。您不应该使用上面的示例从函数返回它。要获得非临时的LPWSTR，您应该在堆上复制原始字符串。请检查下面的示例：

LPWSTR ConvertToLPWSTR( const std::string& s )
{
  LPWSTR ws = new wchar_t[s.size()+1]; // +1 for zero at the end
  copy( s.begin(), s.end(), ws );
  ws[s.size()] = 0; // zero at the end
  return ws;
}

void f()
{
  std::string s = SOME_STRING;
  LPWSTR ws = ConvertToLPWSTR( s );

  // some actions

  delete[] ws; // caller responsible for deletion
}

Charles Bailey给出的MultiByteToWideChar答案是正确的，因为LPCWSTR只是const WCHAR*的一个typedef，所以示例代码中的widestr可以用在任何需要LPWSTR或LPCWSTR的地方。
一个小的调整是使用std::vector<WCHAR>而不是手动管理的阵列：

// using vector, buffer is deallocated when function ends
std::vector<WCHAR> widestr(bufferlen + 1);

::MultiByteToWideChar(CP_ACP, 0, instr.c_str(), instr.size(), &widestr[0], bufferlen);

// Ensure wide string is null terminated
widestr[bufferlen] = 0;

// no need to delete; handled by vector

另外，如果需要从宽字符串开始，可以使用std::wstring而不是std::string。如果要使用Windows TCHAR类型，您可以使用std::basic_string<TCHAR>。从std::wstring转换为LPCWSTR或从std::basic_string<TCHAR>转换为LPCTSTR只需调用c_str即可。我们在ANSI和UTF-16字符之间切换，MultiByteToWideChar（及其逆WideCharToMultiByte）出现在画面中。

转换很简单：

std::string myString;

LPCSTR lpMyString = myString.c_str();

这里需要注意的一点是c_str并不返回myString的副本，而只是一个指向std：：string Package 的字符串的指针，如果你想要一个副本，你需要使用strcpy自己做一个。

转换很简单：

std::string str;
LPCSTR lpcstr = str.c_str();

在我看来，将std::string转换为LPWSTR的最简单方法是：
1.将std::string转换为std::vector<wchar_t>
1.取向量中第一个wchar_t的地址。
std::vector<wchar_t>有一个模板化的ctor，它将接受两个迭代器，比如std::string.begin()和.end()迭代器。但是，这会将每个字符转换为wchar_t。由于Unicode值类似于Latin-1值，因此仅当std::string包含ASCII或Latin-1时才有效。如果它包含CP 1252或任何其他编码的字符，就更复杂了。你需要转换字符。

std::string myString("SomeValue");
LPSTR lpSTR = const_cast<char*>(myString.c_str());

• myString* 是输入字符串，lpSTR 是它的LPSTR等效项。