c++ - কিভাবে একটি স্ট ডি:: স্ট্রিং কনস্টেবল গৃহস্থালি*বা গৃহস্থালি*রূপান্তর করবেন?




string char (6)

সি ++ 17

C ++ 17 (আসন্ন মান) টেমপ্লেটটির সারসংক্ষেপগুলি পরিবর্তন করে basic_string data() অ- basic_string ওভারলোড যোগ data() :

charT* data() noexcept;

রিটার্নস: একটি পয়েন্টার পি যেমন যে আমি প্রতি [0, আকার ()] জন্য পি + i == এবং অপারেটর।

CharT const * std::basic_string<CharT> থেকে CharT const *

std::string const cstr = { "..." };
char const * p = cstr.data(); // or .c_str()

CharT * std::basic_string<CharT> থেকে CharT *

std::string str = { "..." };
char * p = str.data();

সি ++ 11

CharT const * std::basic_string<CharT> থেকে CharT const *

std::string str = { "..." };
str.c_str();

CharT * std::basic_string<CharT> থেকে CharT *

সি ++ থেকে 11 এর পরে, স্ট্যান্ডার্ডটি বলে:

  1. একটি basic_string বস্তুর গৃহস্থালি-মত বস্তুগুলি basic_string সংরক্ষণ করা হবে। অর্থাৎ, কোনো basic_string বস্তুর জন্য, পরিচয় &*(s.begin() + n) == &*s.begin() + n সমস্ত মান ধরে রাখতে হবে যেমন 0 <= n < s.size()
  1. const_reference operator[](size_type pos) const;
    reference operator[](size_type pos);

    রিটার্নস: *(begin() + pos) pos < size() , অন্যথায় মূল্য CharT() সহ CharT টাইপের একটি বস্তুর একটি রেফারেন্স; রেফারেন্স মান পরিবর্তন করা হবে না।

  1. const charT* c_str() const noexcept;
    const charT* data() const noexcept;

    ফেরত: একটি পয়েন্টার পি যেমন যে p + i == &operator[](i) প্রতিটি i [0,size()]

একটি অনির্বাচিত অক্ষর পয়েন্টার পেতে severable সম্ভাব্য উপায় আছে।

1. সি ++ 11 এর সামঞ্জস্যপূর্ণ স্টোরেজ ব্যবহার করুন

std::string foo{"text"};
auto p = &*foo.begin();

স্বপক্ষে

  • সহজ এবং সংক্ষিপ্ত
  • দ্রুত (কোন কপি জড়িত সঙ্গে শুধুমাত্র পদ্ধতি)

কনস

  • চূড়ান্ত '\0' পরিবর্তন করা হবে না অগত্যা অ-স্মৃতি স্মৃতির অংশ।

2. std::vector<CharT> ব্যবহার std::vector<CharT>

std::string foo{"text"};
std::vector<char> fcv(foo.data(), foo.data()+foo.size()+1u);
auto p = fcv.data();

স্বপক্ষে

  • সহজ
  • স্বয়ংক্রিয় মেমরি হ্যান্ডলিং
  • প্রগতিশীল

কনস

  • স্ট্রিং কপি প্রয়োজন

3. std::array<CharT, N> যদি N সময় ধ্রুবক কম্পাইল হয় (এবং যথেষ্ট ছোট)

std::string foo{"text"};
std::array<char, 5u> fca;
std::copy(foo.data(), foo.data()+foo.size()+1u, fca.begin());

স্বপক্ষে

  • সহজ
  • মেমরি হ্যান্ডলিং স্ট্যাক

কনস

  • স্থির
  • স্ট্রিং কপি প্রয়োজন

4. স্বয়ংক্রিয় স্টোরেজ মুছে ফেলার সঙ্গে কাঁচা মেমরি বরাদ্দ

std::string foo{ "text" };
auto p = std::make_unique<char[]>(foo.size()+1u);
std::copy(foo.data(), foo.data() + foo.size() + 1u, &p[0]);

স্বপক্ষে

  • ছোট মেমরি পদচিহ্ন
  • স্বয়ংক্রিয় মুছে ফেলা
  • সহজ

কনস

  • স্ট্রিং কপি প্রয়োজন
  • স্ট্যাটিক (গতিশীল ব্যবহারের অনেক কোড প্রয়োজন)
  • ভেক্টর বা অ্যারের চেয়ে কম বৈশিষ্ট্য

5. ম্যানুয়াল হ্যান্ডলিং সঙ্গে কাঁচা মেমরি বরাদ্দ

std::string foo{ "text" };
char * p = nullptr;
try
{
  p = new char[foo.size() + 1u];
  std::copy(foo.data(), foo.data() + foo.size() + 1u, p);
  // handle stuff with p
  delete[] p;
}
catch (...)
{
  if (p) { delete[] p; }
  throw;
}

স্বপক্ষে

  • সর্বাধিক 'নিয়ন্ত্রণ'

বিরূদ্ধে

  • স্ট্রিং কপি প্রয়োজন
  • সর্বোচ্চ দায় / ত্রুটি জন্য সংবেদনশীলতা
  • জটিল

আমি কিভাবে একটি std::string char* বা একটি const char* char* রূপান্তর করতে পারি?


আমি অনেকগুলি ফাংশন সহ একটি API সহ কাজ করছি একটি char* হিসাবে একটি char*

আমি এই ধরনের সমস্যার মুখোমুখি হতে একটি ছোট বর্গ তৈরি করেছি, আমি রাই আইডিয়ম বাস্তবায়ন করেছি।

class DeepString
{
        DeepString(const DeepString& other);
        DeepString& operator=(const DeepString& other);
        char* internal_; 

    public:
        explicit DeepString( const string& toCopy): 
            internal_(new char[toCopy.size()+1]) 
        {
            strcpy(internal_,toCopy.c_str());
        }
        ~DeepString() { delete[] internal_; }
        char* str() const { return internal_; }
        const char* c_str()  const { return internal_; }
};

এবং আপনি এটি ব্যবহার করতে পারেন:

void aFunctionAPI(char* input);

//  other stuff

aFunctionAPI("Foo"); //this call is not safe. if the function modified the 
                     //literal string the program will crash
std::string myFoo("Foo");
aFunctionAPI(myFoo.c_str()); //this is not compiling
aFunctionAPI(const_cast<char*>(myFoo.c_str())); //this is not safe std::string 
                                                //implement reference counting and 
                                                //it may change the value of other
                                                //strings as well.
DeepString myDeepFoo(myFoo);
aFunctionAPI(myFoo.str()); //this is fine

আমি ক্লাস DeepString নামে পরিচিত কারণ এটি একটি বিদ্যমান স্ট্রিংটির একটি গভীর এবং অনন্য অনুলিপি (গভীর DeepString নয়) তৈরি করছে।


দেওয়া হয়েছে ...

std::string x = "hello";

একটি `স্ট্রিং` থেকে` গৃহস্থালি * `বা 'কনস্টেবল গৃহস্থালি *` পেয়ে

x অক্ষর থাকা অবস্থায় বৈধ অক্ষর পয়েন্টারটি কীভাবে পেতে হয় এবং আরও সংশোধন করা হয় না

সি ++ 11 জিনিস সহজ করে; নিম্নলিখিত সমস্ত একই অভ্যন্তরীণ স্ট্রিং বাফার অ্যাক্সেস দিতে:

const char* p_c_str = x.c_str();
const char* p_data  = x.data();
const char* p_x0    = &x[0];

      char* p_x0_rw = &x[0];  // compiles iff x is not const...

উপরের সমস্ত পয়েন্টার একই মান ধরে রাখবে - বাফারের প্রথম চরিত্রের ঠিকানা। এমনকি একটি খালি স্ট্রিংটি "বাফারে প্রথম চরিত্র" রয়েছে, কারণ C ++ 11 স্পষ্টভাবে নির্ধারিত স্ট্রিং সামগ্রী (যেমন std::string("this\0that", 9) পরে একটি অতিরিক্ত NUL / 0 টারমিনেটর চরিত্রকে সবসময় রাখতে দেয়) std::string("this\0that", 9) "this\0that\0" ধারণ করে একটি বাফার থাকবে)।

উপরের পয়েন্টারগুলির মধ্যে যেকোনো একটি দেওয়া আছে:

char c = p[n];   // valid for n <= x.size()
                 // i.e. you can safely read the NUL at p[x.size()]

শুধুমাত্র অ- const পয়েন্টারের জন্য &x[0] :

p_x0_rw[n] = c;  // valid for n <= x.size() - 1
                 // i.e. don't overwrite the implementation maintained NUL

স্ট্রিং এর অন্যত্র একটি NUL লেখার string এর size() পরিবর্তন করা হয় না size() ; string NULs এর সংখ্যা অন্তর্ভুক্ত করার অনুমতি দেওয়া হয় - তাদের স্টেড std::string (সি ++ 03 তে একই রকম) দ্বারা কোনও বিশেষ চিকিত্সা দেওয়া হয় না।

সি ++ 03 এ , জিনিসগুলি আরও জটিল ছিল (মূল পার্থক্যগুলি হাইলাইট করা হয়েছে ):

  • x.data()

    • স্ট্রিং এর অভ্যন্তরীণ বাফারের জন্য const char* প্রদান করে যা স্ট্যান্ডার্ড দ্বারা একটি NUL (অর্থাত্ ['h', 'e', 'l', 'l', 'o'] বা আবর্জনা মান, দুর্ঘটনাজনিত অ্যাক্সেস সঙ্গে অনির্ধারিত আচরণ থাকার)।
      • x.size() অক্ষরগুলি পড়তে নিরাপদ, অর্থাত x[0] x[x.size() - 1]
      • ফাঁকা স্ট্রিংগুলির জন্য, আপনি কিছু অ-নূল পয়েন্টার নিশ্চিত করেছেন যা 0 নিরাপদে যোগ করা যেতে পারে (হরে!), তবে আপনি পয়েন্টারটিকে অস্বীকার করবেন না।
  • &x[0]

    • খালি স্ট্রিং জন্য এই আচরণ অনির্ধারিত হয়েছে (21.3.4)
      • উদাহরণস্বরূপ f(const char* p, size_t n) { if (n == 0) return; ...whatever... } f(const char* p, size_t n) { if (n == 0) return; ...whatever... } আপনি f(&x[0], x.size()); কল করতে পারবেন না f(&x[0], x.size()); যখন x.empty() - শুধুমাত্র f(x.data(), ...)
    • অন্যথা, x.data() তবে:
      • const x এটি একটি non- const char* পয়েন্টার ফলন করে; আপনি স্ট্রিং কন্টেন্ট overwrite করতে পারেন
  • x.c_str()

    • মান (যেমন 'এইচ', 'ই', 'এল', 'এল', 'ও', '\ 0']) একটি ASCIIZ (NUL-terminated) উপস্থাপনাতে কনস্টেবল const char* প্রদান করে।
    • যদিও কোনও বাস্তবায়নের জন্য এটি করা বেছে নেওয়া হয়েছে তবে সি ++ 03 স্ট্যান্ডার্ডটি স্ট্রিং বাস্তবায়নকে ফ্লাইটে একটি স্বতন্ত্র NUL-terminated বাফার তৈরি করার অনুমতি দেওয়া হয়েছিল, সম্ভাব্য নন-এনএল বাতিল হওয়া বাফারটি x.data() দ্বারা "উন্মুক্ত" থেকে x.data() এবং &x[0]
    • x.size() + 1 অক্ষর পড়তে নিরাপদ।
    • খালি স্ট্রিংগুলির জন্য এমনকি নিরাপদ (['\ 0']) নিশ্চিত।

বাইরে আইনি সূচক অ্যাক্সেসের ফলাফল

আপনি যে কোনও পয়েন্টার পাবেন, উপরে বর্ণিত বিবরণগুলিতে উপস্থিত নিশ্চিত হওয়া চরিত্রগুলির চেয়ে পয়েন্টারের পাশাপাশি মেমরি অ্যাক্সেস করতে হবে না। এটি করার প্রচেষ্টাগুলি অনির্ধারিত আচরণ , অ্যাপ্লিকেশনের ক্র্যাশ এবং আবর্জনা ফলাফলের খুব বাস্তব সুযোগ সহ এমনকি পড়ার জন্য এবং অতিরিক্তভাবে পাইকারি ডেটা, দুর্নীতি এবং / অথবা লেখার জন্য নিরাপত্তা দুর্বলতাগুলি স্ট্যাক করে।

যখন যারা পয়েন্টার অবৈধ পেতে পারি?

যদি আপনি কিছু string সদস্য ফাংশন কল করেন যা string সংশোধন করে বা আরও ক্ষমতা সংরক্ষণ করে তবে উপরে উল্লেখিত কোনও পদ্ধতিতে পূর্বে কোনও পয়েন্টার মানগুলি ফেরত দেওয়া হয় না। আপনি অন্য পয়েন্টার পেতে আবার যারা পদ্ধতি ব্যবহার করতে পারেন। (নিয়ম string এর মধ্যে iterators জন্য একই)।

x পাতার সুযোগ ছাড়াইও একটি চরিত্র পয়েন্টারটি বৈধ কীভাবে পাওয়া যায় বা আরও নীচে সংশোধন করা হয় তা দেখুন।

সুতরাং, যা ব্যবহার করা ভাল ?

C ++ 11 থেকে, ASCIIZ তথ্যের জন্য .c_str() ব্যবহার করুন এবং .data() "বাইনারি" তথ্যের জন্য (নীচে ব্যাখ্যা করুন)।

C ++ 03 তে, .c_str() ব্যবহার না করে নির্দিষ্ট না হওয়া পর্যন্ত .data() যথেষ্ট এবং পছন্দসই .data() &x[0] কারণ এটি খালি স্ট্রিংগুলির জন্য নিরাপদ।

... যথাযথ যখন data() ব্যবহার করতে যথেষ্ট প্রোগ্রাম বুঝতে চেষ্টা করুন, অথবা আপনি সম্ভবত অন্যান্য ভুল করতে হবে ...

.c_str() দ্বারা গ্যারান্টিযুক্ত ASCII NUL '\ 0' চরিত্রটি প্রাসঙ্গিক এবং নিরাপদ-অ্যাক্সেসের ডেটা শেষ করার নির্দেশ করে এমন একটি .c_str() মান হিসাবে অনেকগুলি ফাংশন দ্বারা ব্যবহৃত হয়। এটি C ++ উভয় ক্ষেত্রে প্রযোজ্য - শুধুমাত্র ফাংশন যেমন fstream::fstream(const char* filename, ...) এবং strchr() -সি-সি ফাংশন যেমন strchr() , এবং printf()

প্রদত্ত .c_str() দেওয়া C ++ 03 এর .c_str() এর গ্যারান্টী .c_str() এর একটি অতি-সেট, আপনি সর্বদা নিরাপদভাবে .c_str() ব্যবহার করতে পারেন, কিন্তু লোকেরা কখনও কখনও এটি কারণ করে না:

  • .data() ব্যবহার করে অন্যান্য প্রোগ্রামারদের সোর্স কোডটি পড়ার সাথে যোগাযোগ করে যে তথ্যটি ASCIIZ নয় (বরং, আপনি তথ্যগুলির একটি ব্লক সংরক্ষণ করতে স্ট্রিং ব্যবহার করছেন (যা কখনও কখনও এমনকি পাঠ্যপুস্তকও নয়)), অথবা আপনি যে ' এটি "ফাংশন বাইনারি" তথ্য হিসাবে একটি ব্লক হিসাবে এটি অন্য ফাংশন এটি পাস। অন্যান্য প্রোগ্রামারদের কোড পরিবর্তনগুলি সঠিকভাবে ডেটা পরিচালনা করা চালিয়ে যেতে এটি একটি গুরুত্বপূর্ণ অন্তর্দৃষ্টি হতে পারে।
  • C ++ 03 শুধুমাত্র: আপনার string বাস্তবায়নে কিছু অতিরিক্ত মেমরি বরাদ্দ এবং / অথবা নকল সমাপ্তির বাফার প্রস্তুত করার জন্য ডেটা কপি করার সামান্য সুযোগ আছে

আরো ইঙ্গিত হিসাবে, যদি একটি ফাংশন এর পরামিতিগুলি ( const ) char* তবে x.size() পেতে জোর দেয় না, ফাংশনটি সম্ভবত একটি ASCIIZ ইনপুট প্রয়োজন, তাই .c_str() একটি ভাল পছন্দ (ফাংশনটির প্রয়োজন পাঠ্যটি কোথাও শেষ হয়ে যায় তা জানতে, তাই এটি যদি পৃথক প্যারামিটার না হয় তবে এটি কেবল লম্বা-পূর্বরূপ বা সেন্সিনেল বা কিছু নির্দিষ্ট প্রত্যাশিত দৈর্ঘ্যের মত একটি কনভেনশন হতে পারে)।

x পাতার সুযোগ ছাড়াই বা আরও সংশোধন করা হয় এমন একটি চরিত্র পয়েন্টার কীভাবে পেতে হবে

আপনি x বাইরে একটি নতুন মেমরি এলাকাতে string x এর বিষয়বস্তু অনুলিপি করতে হবে। এই বহিরাগত বাফারটি অন্য string বা ক্যারেক্টার অ্যারে পরিবর্তনশীল হিসাবে অনেক জায়গায় হতে পারে, এটি একটি ভিন্ন সুযোগ থাকা (যেমন নামস্পেস, বিশ্বব্যাপী, স্ট্যাটিক, হিপ, ভাগ করা মেমরি, মেমরি ম্যাপডের কারণে x চেয়ে ভিন্ন জীবনকাল হতে পারে বা নাও থাকতে পারে)। ফাইল)।

std::string x থেকে একটি স্বাধীন চরিত্র অ্যারে থেকে পাঠ্য অনুলিপি করতে:

// USING ANOTHER STRING - AUTO MEMORY MANAGEMENT, EXCEPTION SAFE
std::string old_x = x;
// - old_x will not be affected by subsequent modifications to x...
// - you can use `&old_x[0]` to get a writable char* to old_x's textual content
// - you can use resize() to reduce/expand the string
//   - resizing isn't possible from within a function passed only the char* address

std::string old_x = x.c_str(); // old_x will terminate early if x embeds NUL
// Copies ASCIIZ data but could be less efficient as it needs to scan memory to
// find the NUL terminator indicating string length before allocating that amount
// of memory to copy into, or more efficient if it ends up allocating/copying a
// lot less content.
// Example, x == "ab\0cd" -> old_x == "ab".

// USING A VECTOR OF CHAR - AUTO, EXCEPTION SAFE, HINTS AT BINARY CONTENT, GUARANTEED CONTIGUOUS EVEN IN C++03
std::vector<char> old_x(x.data(), x.data() + x.size());       // without the NUL
std::vector<char> old_x(x.c_str(), x.c_str() + x.size() + 1);  // with the NUL

// USING STACK WHERE MAXIMUM SIZE OF x IS KNOWN TO BE COMPILE-TIME CONSTANT "N"
// (a bit dangerous, as "known" things are sometimes wrong and often become wrong)
char y[N + 1];
strcpy(y, x.c_str());

// USING STACK WHERE UNEXPECTEDLY LONG x IS TRUNCATED (e.g. Hello\0->Hel\0)
char y[N + 1];
strncpy(y, x.c_str(), N);  // copy at most N, zero-padding if shorter
y[N] = '\0';               // ensure NUL terminated

// USING THE STACK TO HANDLE x OF UNKNOWN (BUT SANE) LENGTH
char* y = alloca(x.size() + 1);
strcpy(y, x.c_str());

// USING THE STACK TO HANDLE x OF UNKNOWN LENGTH (NON-STANDARD GCC EXTENSION)
char y[x.size() + 1];
strcpy(y, x.c_str());

// USING new/delete HEAP MEMORY, MANUAL DEALLOC, NO INHERENT EXCEPTION SAFETY
char* y = new char[x.size() + 1];
strcpy(y, x.c_str());
//     or as a one-liner: char* y = strcpy(new char[x.size() + 1], x.c_str());
// use y...
delete[] y; // make sure no break, return, throw or branching bypasses this

// USING new/delete HEAP MEMORY, SMART POINTER DEALLOCATION, EXCEPTION SAFE
// see boost shared_array usage in Johannes Schaub's answer

// USING malloc/free HEAP MEMORY, MANUAL DEALLOC, NO INHERENT EXCEPTION SAFETY
char* y = strdup(x.c_str());
// use y...
free(y);

অন্য কারণগুলি একটি char* বা const char* একটি string থেকে তৈরি করতে চান

সুতরাং, উপরে দেখেন কিভাবে একটি ( const ) char* , এবং কীভাবে মূল string const লেখাটি তৈরি করতে হয়, কিন্তু এর সাথে আপনি কী করতে পারেন? উদাহরণস্বরূপ একটি এলোমেলো smattering ...

  • "সি" কোডটি C ++ string এর পাঠ্যতে প্রবেশ করুন, যেমন printf("x is '%s'", x.c_str());
  • আপনার ফাংশনের কলার দ্বারা নির্দিষ্ট একটি বাফারে x এর পাঠ্য অনুলিপি করুন (উদাহরণস্বরূপ strncpy(callers_buffer, callers_buffer_size, x.c_str()) ), বা ডিভাইস I / O (উদাহরণস্বরূপ for (const char* p = x.c_str(); *p; ++p) *p_device = *p; ) এর জন্য ব্যবহৃত অস্থায়ী মেমরি for (const char* p = x.c_str(); *p; ++p) *p_device = *p; )
  • x অক্ষরটি একটি অক্ষর অ্যারে যুক্ত করুন যা ইতিমধ্যে কিছু ASCIIZ পাঠ্য রয়েছে (উদাহরণস্বরূপ strcat(other_buffer, x.c_str()) ) - সতর্কতা অবলম্বন করুন বাফারকে strcat(other_buffer, x.c_str()) করা না (অনেক ক্ষেত্রে আপনাকে strncat ব্যবহার করতে হবে)
  • একটি ফাংশন থেকে একটি const char* বা char* (সম্ভবত ঐতিহাসিক কারণে - ক্লায়েন্ট আপনার বিদ্যমান API ব্যবহার করে - অথবা সি সামঞ্জস্যের জন্য আপনি std::string ফেরত দিতে চান না তবে আপনার string তথ্য অনুলিপি করতে চান কলার জন্য কোথাও)
    • কোনও পয়েন্টারকে ফেরত না দেওয়ার বিষয়ে সাবধান হোন যা কোন স্থানীয় string ভেরিয়েবলের পরে কলার দ্বারা ডিফারেন্স করা যেতে পারে, যা পয়েন্টারের দিকে তাকাতে পারে
    • বিভিন্ন স্টেড std::string বাস্তবায়নের জন্য সংযুক্ত / ভাগ করা বস্তুর সাথে কিছু প্রকল্পগুলি (উদাহরণস্বরূপ STLport এবং কম্পাইলার-নেটিভ) দ্বন্দ্ব এড়ানোর জন্য ASCIIZ হিসাবে তথ্য পাস করতে পারে

যদি আপনি std::string কোনও ফাংশনে পাস করতে চান যা const char* ব্যবহার করতে পারে

std::string str;
const char * c = str.c_str();

যদি আপনি একটি লেখার কপি পেতে চান, যেমন char * , আপনি এটির সাথে এটি করতে পারেন:

std::string str;
char * writable = new char[str.size() + 1];
std::copy(str.begin(), str.end(), writable);
writable[str.size()] = '\0'; // don't forget the terminating 0

// don't forget to free the string after finished using it
delete[] writable;

সম্পাদনা : উপরে উল্লেখ্য যে ব্যতিক্রমটি নিরাপদ নয়। new কল এবং delete কলগুলির মধ্যে যেকোনো কিছু থাকলে আপনি মেমরি লিক করবেন, যেহেতু কিছুই স্বয়ংক্রিয়ভাবে আপনার জন্য delete ফেলবে না। এই সমাধানের জন্য দুটি অবিলম্বে উপায় আছে।

অনুমোদন :: scoped_array

boost::scoped_array সুযোগ ছাড়াই আপনার জন্য স্মৃতি মুছে ফেলবে:

std::string str;
boost::scoped_array<char> writable(new char[str.size() + 1]);
std::copy(str.begin(), str.end(), writable.get());
writable[str.size()] = '\0'; // don't forget the terminating 0

// get the char* using writable.get()

// memory is automatically freed if the smart pointer goes 
// out of scope

এসটিডি :: ভেক্টর

এটি স্ট্যান্ডার্ড উপায় (কোন বহিরাগত লাইব্রেরি প্রয়োজন হয় না)। আপনি std::vector ব্যবহার করেন যা সম্পূর্ণরূপে আপনার জন্য মেমরি পরিচালনা করে।

std::string str;
std::vector<char> writable(str.begin(), str.end());
writable.push_back('\0');

// get the char* using &writable[0] or &*writable.begin()

.c_str() const char * জন্য .c_str() পদ্ধতিটি ব্যবহার করুন।

আপনি char * পয়েন্টার পেতে &mystring[0] ব্যবহার করতে পারেন &mystring[0] ব্যবহার করতে পারেন, তবে কয়েকটি গোচা আছে: আপনি অবশ্যই একটি শূন্য বন্ধ হওয়া স্ট্রিং পাবেন না এবং আপনি স্ট্রিং এর আকার পরিবর্তন করতে পারবেন না। আপনি বিশেষভাবে সতর্কতা অবলম্বন করতে হবে স্ট্রিং শেষের পূর্বে অক্ষর যোগ না করা বা আপনি একটি বাফার overrun (এবং সম্ভাব্য ক্র্যাশ) overrun পাবেন।

কোনও গ্যারান্টি নেই যে সমস্ত অক্ষরগুলি সি ++11 পর্যন্ত একই সংলগ্ন বাফারের অংশ হবে, কিন্তু std::string সকল পরিচিতিগুলি যেভাবেই কাজ করেছিল; দেখুন "& s [0]" একটি স্টেড :: স্ট্রিং এর সাথে সংযুক্ত অক্ষরগুলিকে নির্দেশ করে?

উল্লেখ্য যে অনেক string সদস্য ফাংশন অভ্যন্তরীণ বাফারকে পুনরায় স্থাপন করবে এবং আপনি যে কোনও পয়েন্টার সংরক্ষণ করতে পারে তা অকার্যকর করবে। অবিলম্বে তাদের ব্যবহার করতে এবং তারপর বাতিল করা ভাল।


char* result = strcpy((char*)malloc(str.length()+1), str.c_str());





const