LPCSTR में std :: string कैसे कन्वर्ट करें?

Question

कैसे मैं एक में बदल सकते हैं std::stringकरने के लिए LPCSTR? इसके अलावा, मैं कैसे एक में बदल सकते हैं std::stringकरने के लिए LPWSTR?

मैं इन LPCSTR LPSTR LPWSTRऔर के साथ पूरी तरह से भ्रमित हूँ LPCWSTR।

कर रहे हैं LPWSTRऔर LPCWSTRएक ही?

Answer 1

str.c_str()आपको एक देता है const char *, जो एक LPCSTR(लॉन्ग पॉइंटर टू कॉन्स्टेंट स्ट्रॉन्ग) है - इसका मतलब है कि यह 0पात्रों के समाप्त स्ट्रिंग के लिए एक संकेतक है । Wविस्तृत स्ट्रिंग का मतलब है (के wchar_tबजाय से बना char)।

Comments

मामूली अचार बिंदु: X64 पर LPCSTR एक (निरंतर) अशक्त-समाप्त स्ट्रिंग के लिए 64-बिट सूचक होगा।

— जोएल

Answer 2

कॉल c_str()एक पाने के लिए const char *( LPCSTR) एक से std::string।

यह सब नाम में है:

LPSTR - (लंबी) सूचक स्ट्रिंग के लिए - char *

LPCSTR - (लंबी) पॉइंटर से लगातार स्ट्रिंग - const char *

LPWSTR - (लंबी) सूचक यूनिकोड (चौड़ी) स्ट्रिंग - wchar_t *

LPCWSTR - (लंबी) सूचक निरंतर यूनिकोड (चौड़ी) स्ट्रिंग - const wchar_t *

LPTSTR - (लंबी) सूचक TCHAR (यूनिकोड यदि UNICODE परिभाषित है, तो ANSI नहीं) स्ट्रिंग - TCHAR *

LPCTSTR - (लंबी) सूचक लगातार TCHAR स्ट्रिंग के लिए - const TCHAR *

आप नामों के एल (लंबे) हिस्से को अनदेखा कर सकते हैं - यह 16-बिट विंडोज से होल्डओवर है।

Answer 3

ये Microsoft परिभाषित टाइपफेड हैं जो इसके अनुरूप हैं:

LPCSTR: पॉइंटर को नेल टर्मिनेटेड कास्ट स्ट्रिंग ऑफ नेल char

एलपीटीएस: पॉइंटर ऑफ नेलिनेटेड चार स्ट्रिंग ऑफ 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और केवल तब तक मान्य होगा जब तक कि स्ट्रिंग अगली बार संशोधित या नष्ट न हो जाए।

A को कन्वर्ट करने के std::stringलिए a LPWSTRऔर अधिक जटिल है। एक चाहते LPWSTRसंकेत मिलता है कि आप एक परिवर्तनीय बफर की जरूरत है और आप यह भी सुनिश्चित करें कि आप समझते क्या करने की आवश्यकता है चरित्र एन्कोडिंगstd::string उपयोग कर रहा है। यदि std::stringसिस्टम डिफ़ॉल्ट एन्कोडिंग का उपयोग करके एक स्ट्रिंग शामिल है (विंडोज़, यहां पर), तो आप आवश्यक विस्तृत वर्ण बफर की लंबाई पा सकते हैं और उपयोग करके ट्रांसकोडिंग कर सकते हैंMultiByteToWideChar (Win32 एपीआई फ़ंक्शन)।

जैसे

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;
}

Answer 4

उपयोग करने से 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
}

Answer 5

MultiByteToWideCharजवाब यह है कि चार्ल्स बेली दिया सही से एक है। क्योंकि उदाहरण के लिए कोड में LPCWSTRसिर्फ एक टाइपराइफ होता है const WCHAR*, जहां 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। यदि आप विंडोज TCHARप्रकार के साथ काम करना चाहते हैं , तो आप उपयोग कर सकते हैं std::basic_string<TCHAR>। से परिवर्तित std::wstringकरने के लिए LPCWSTRया से std::basic_string<TCHAR>करने के लिएLPCTSTR बुला का मामला है c_str। यह तब होता है जब आप ANSI और UTF-16 वर्णों के बीच बदल रहे होते हैं MultiByteToWideChar(और इसका उलटा WideCharToMultiByte) चित्र में आता है।

Answer 6

रूपांतरण सरल है:

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

Answer 7

परिवर्तित सरल है:

std::string myString;

LPCSTR lpMyString = myString.c_str();

यहाँ एक बात ध्यान रखनी चाहिए कि c_str myString की एक प्रति वापस नहीं करता है, लेकिन चरित्र स्ट्रिंग के लिए सिर्फ एक सूचक है जो std :: string wraps। यदि आप चाहते हैं / एक प्रति की आवश्यकता है, तो आपको स्ट्रैपी का उपयोग करके खुद को बनाने की आवश्यकता होगी।

Answer 8

मेरे विचार में std::stringa को बदलने का सबसे आसान तरीका है LPWSTR:

1. कन्वर्ट std::stringएक करने के लिएstd::vector<wchar_t>
2. wchar_tवेक्टर में पहले का पता लें ।

std::vector<wchar_t>एक अस्थायी ctor है जो दो पुनरावृत्तियों को ले जाएगा, जैसे कि std::string.begin()और .end()पुनरावृत्त। हालांकि यह प्रत्येक चार को एक में बदल देगा wchar_t। यह केवल तभी मान्य std::stringहोता है जब यूनिकोड मान जिस तरह से ASCII या लैटिन -1 होता है, वह लैटिन -1 मूल्यों से मिलता जुलता है। यदि इसमें CP1252 या किसी अन्य एन्कोडिंग के वर्ण हैं, तो यह अधिक जटिल है। फिर आपको वर्ण बदलने की आवश्यकता होगी।

Comments

क्यों नहीं इस्तेमाल करते? std::wstring ?

— टिम्मम

@Timmmm: C ++ 11 ने विनिर्देश को कड़ा कर दिया क्योंकि कार्यान्वयन पुराने नियमों का लाभ नहीं उठाते थे, आज यह ठीक होगा।

— MSalters

Answer 9

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

myString इनपुट स्ट्रिंग है और lpSTR यह एलपीटीएस समकक्ष है।