Bagaimana saya bisa mengonversikan std::stringke char*atau const char*?

Jika Anda hanya ingin meneruskan std::stringke fungsi yang perlu const char*Anda dapat gunakan

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

Jika Anda ingin mendapatkan salinan yang dapat ditulisi char *, Anda dapat melakukannya dengan ini:

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;

Sunting : Perhatikan bahwa di atas tidak terkecuali aman. Jika ada sesuatu antara newpanggilan dan deletepanggilan yang dilemparkan, Anda akan membocorkan memori, karena tidak ada yang memanggil deleteAnda secara otomatis. Ada dua cara langsung untuk menyelesaikan ini.

boost :: scoped_array

boost::scoped_array akan menghapus memori untuk Anda setelah keluar dari ruang lingkup:

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 :: vektor

Ini adalah cara standar (tidak memerlukan perpustakaan eksternal). Anda menggunakan std::vector, yang sepenuhnya mengelola memori untuk Anda.

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

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

Diberikan katakan ...

std::string x = "hello";

Mendapatkan `char *` atau `const char *` dari `string`

Cara mendapatkan penunjuk karakter yang valid sambil xtetap dalam cakupan dan tidak dimodifikasi lebih lanjut

C ++ 11 menyederhanakan banyak hal; semua yang berikut memberikan akses ke buffer string internal yang sama:

const char* p_c_str = x.c_str();
const char* p_data  = x.data();
char* p_writable_data = x.data(); // for non-const x from C++17 
const char* p_x0    = &x[0];

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

Semua petunjuk di atas akan memiliki nilai yang sama - alamat karakter pertama di buffer. Bahkan string kosong memiliki "karakter pertama dalam buffer", karena C ++ 11 menjamin untuk selalu menyimpan karakter terminator NUL / 0 tambahan setelah konten string yang ditetapkan secara eksplisit (mis. std::string("this\0that", 9)Akan memiliki holding buffer "this\0that\0").

Diberikan salah satu petunjuk di atas:

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

Hanya untuk yang bukan constpenunjuk p_writable_datadan dari &x[0]:

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

Menulis NUL di tempat lain dalam string tidak mengubah string's size(); stringDiijinkan mengandung sejumlah NUL - mereka tidak diberi perlakuan khusus oleh std::string(sama dalam C ++ 03).

Di C ++ 03 , hal-hal yang jauh lebih rumit (perbedaan utama disorot ):

• x.data()

  • kembali const char*ke buffer internal string yang tidak diperlukan oleh Standar untuk menyimpulkan dengan NUL (yaitu mungkin ['h', 'e', 'l', 'l', 'o']diikuti oleh nilai-nilai tidak diinisialisasi atau sampah, dengan akses tidak disengaja yang memiliki perilaku yang tidak ditentukan ).
    • x.size()karakter aman untuk dibaca, yaitu x[0]melaluix[x.size() - 1]
    • untuk string kosong, Anda dijamin beberapa pointer NULL yang 0 dapat ditambahkan dengan aman (hore!), tetapi Anda tidak boleh dereferensi pointer itu.

• &x[0]

  • untuk string kosong ini memiliki perilaku yang tidak jelas (21.3.4)
    • mis. diberikan f(const char* p, size_t n) { if (n == 0) return; ...whatever... }Anda tidak harus menelepon f(&x[0], x.size());kapan x.empty()- gunakan saja f(x.data(), ...).
  • jika tidak, sesuai x.data()tetapi:
    • untuk non- const xini menghasilkan non- const char*pointer; Anda dapat menimpa konten string

• x.c_str()

  • kembali const char*ke representasi ASCIIZ (diakhiri NUL) dari nilai (yaitu ['h', 'e', ​​'l', 'l', 'o', '\ 0']).
  • meskipun sedikit jika ada implementasi yang memilih untuk melakukannya, Standar C ++ 03 diucapkan untuk memungkinkan implementasi string kebebasan untuk membuat buffer NUL-dihentikan dengan cepat , dari buffer yang berpotensi non-NUL yang diakhiri oleh "terkena" oleh x.data()dan&x[0]
  • x.size() +1 karakter aman untuk dibaca.
  • dijamin aman bahkan untuk string kosong (['\ 0']).

Konsekuensi mengakses indeks hukum luar

Dengan cara apa pun Anda mendapatkan pointer, Anda tidak boleh mengakses memori lebih jauh dari pointer daripada karakter dijamin hadir dalam deskripsi di atas. Upaya untuk melakukannya memiliki perilaku yang tidak terdefinisi , dengan kemungkinan crash aplikasi dan hasil sampah yang sangat nyata bahkan untuk dibaca, dan juga data grosir, tumpukan korupsi dan / atau kerentanan keamanan untuk penulisan.

Kapan pointer tersebut dibatalkan?

Jika Anda memanggil beberapa stringfungsi anggota yang memodifikasi stringatau cadangan kapasitas lebih lanjut, nilai pointer apa pun yang dikembalikan sebelumnya dengan salah satu metode di atas tidak valid . Anda dapat menggunakan metode itu lagi untuk mendapatkan pointer lain. (Aturannya sama dengan iterator ke strings).

Lihat juga Cara mendapatkan penunjuk karakter yang valid bahkan setelah xmeninggalkan cakupan atau dimodifikasi lebih lanjut di bawah ....

Jadi, mana yang lebih baik untuk digunakan?

Dari C ++ 11, gunakan .c_str()untuk data ASCIIZ, dan .data()untuk data "biner" (dijelaskan lebih lanjut di bawah).

Dalam C ++ 03, penggunaan .c_str()kecuali tertentu yang .data()memadai, dan lebih memilih .data()lebih &x[0]seperti itu aman untuk string kosong ....

... cobalah untuk memahami program yang cukup untuk digunakan data()saat yang tepat, atau Anda mungkin akan membuat kesalahan lain ...

Karakter ASCII NUL '\ 0' yang dijamin oleh .c_str()digunakan oleh banyak fungsi sebagai nilai sentinel yang menunjukkan akhir data yang relevan dan aman untuk diakses. Ini berlaku untuk C ++ - hanya fungsi seperti fungsi say fstream::fstream(const char* filename, ...)dan shared-with-C seperti strchr(), dan printf().

Mengingat .c_str()jaminan C ++ 03 tentang buffer yang dikembalikan adalah set super .data(), Anda selalu dapat menggunakan dengan aman .c_str(), tetapi orang terkadang tidak melakukannya karena:

• menggunakan .data()komunikasi dengan pemrogram lain yang membaca kode sumber bahwa data tersebut bukan ASCIIZ (melainkan, Anda menggunakan string untuk menyimpan blok data (yang kadang-kadang bahkan tidak benar-benar tekstual)), atau Anda meneruskannya ke fungsi lain yang memperlakukannya sebagai blok data "biner". Ini bisa menjadi wawasan penting dalam memastikan bahwa perubahan kode programmer lain terus menangani data dengan benar.
• Hanya C ++ 03: ada sedikit peluang bahwa stringimplementasi Anda perlu melakukan alokasi memori tambahan dan / atau menyalin data untuk menyiapkan buffer NUL yang dihentikan

Sebagai petunjuk lebih lanjut, jika parameter fungsi memerlukan ( const) char*tetapi tidak bersikeras untuk mendapatkannya x.size(), fungsi tersebut mungkin membutuhkan input ASCIIZ, jadi .c_str()ini adalah pilihan yang baik (fungsi perlu tahu di mana teks berakhir, entah bagaimana, jadi jika tidak parameter yang terpisah hanya dapat berupa konvensi seperti awalan panjang atau sentinel atau panjang yang diharapkan tetap).

Cara mendapatkan penunjuk karakter yang valid bahkan setelah xmeninggalkan ruang lingkup atau dimodifikasi lebih lanjut

Anda harus menyalin konten string xke area memori baru di luar x. Buffer eksternal ini dapat berada di banyak tempat seperti stringvariabel array karakter atau lainnya , mungkin atau mungkin tidak memiliki masa hidup yang berbeda daripada xkarena berada dalam ruang lingkup yang berbeda (mis. Namespace, global, statis, tumpukan, memori bersama, memori yang dipetakan file) .

Untuk menyalin teks dari std::string xke dalam array karakter independen:

// 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);

Alasan lain untuk menginginkan char*atau const char*dihasilkan daristring

Jadi, di atas Anda telah melihat cara mendapatkan ( const) char*, dan cara membuat salinan teks yang independen dari yang asli string, tetapi apa yang dapat Anda lakukan dengannya? Sebuah contoh acak ...

• beri "C" akses kode ke stringteks C ++ , seperti padaprintf("x is '%s'", x.c_str());
• menyalin xteks ke buffer yang ditentukan oleh pemanggil fungsi Anda (mis. strncpy(callers_buffer, callers_buffer_size, x.c_str())), atau memori yang mudah menguap digunakan untuk I / O perangkat (mis. for (const char* p = x.c_str(); *p; ++p) *p_device = *p;)
• tambahkan xteks ke array karakter yang sudah mengandung beberapa teks ASCIIZ (mis. strcat(other_buffer, x.c_str())) - hati-hati jangan sampai menyerbu buffer (dalam banyak situasi Anda mungkin perlu menggunakan strncat)
• mengembalikan sebuah const char*atau char*dari suatu fungsi (mungkin karena alasan historis - klien menggunakan API Anda yang ada - atau untuk kompatibilitas C Anda tidak ingin mengembalikan std::string, tetapi ingin menyalin stringdata Anda di suatu tempat untuk penelepon)
  • hati-hati untuk tidak mengembalikan pointer yang mungkin ditereferensi oleh pemanggil setelah stringvariabel lokal yang menunjuk pointer telah meninggalkan ruang lingkup
  • beberapa proyek dengan objek bersama dikompilasi / ditautkan untuk std::stringimplementasi yang berbeda (mis. STLport dan compiler-native) dapat meneruskan data sebagai ASCIIZ untuk menghindari konflik

Gunakan .c_str()metode untuk const char *.

Anda dapat menggunakan &mystring[0]untuk mendapatkan char *pointer, tetapi ada beberapa gotcha: Anda tidak perlu mendapatkan string yang diakhiri nol, dan Anda tidak akan dapat mengubah ukuran string. Anda terutama harus berhati-hati untuk tidak menambahkan karakter melewati akhir string atau Anda akan mendapatkan buffer overrun (dan kemungkinan crash).

Tidak ada jaminan bahwa semua karakter akan menjadi bagian dari buffer yang bersebelahan yang sama hingga C ++ 11, tetapi dalam praktiknya semua implementasi yang diketahui std::stringtetap bekerja seperti itu; lihat Apakah “& s [0]” menunjuk ke karakter yang berdekatan di std :: string? .

Perhatikan bahwa banyak stringfungsi anggota akan merealokasi buffer internal dan membatalkan semua petunjuk yang mungkin telah Anda simpan. Cara terbaik untuk menggunakannya segera dan kemudian buang.

C ++ 17

C ++ 17 (standar mendatang) mengubah sinopsis templat dengan basic_stringmenambahkan kelebihan non const data():

charT* data() noexcept;

Pengembalian: Pointer p sehingga p + i == & operator untuk setiap i di [0, size ()].

CharT const * dari std::basic_string<CharT>

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

CharT * dari std::basic_string<CharT>

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

C ++ 11

CharT const * dari std::basic_string<CharT>

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

CharT * dari std::basic_string<CharT>

Dari C ++ 11 dan seterusnya, standar mengatakan:

1. Objek char-like dalam basic_stringobjek harus disimpan secara berdekatan. Artinya, untuk basic_stringobjek apa pun s, identitas &*(s.begin() + n) == &*s.begin() + nharus berlaku untuk semua nilai nsedemikian rupa 0 <= n < s.size().

---

2. const_reference operator[](size_type pos) const;
reference operator[](size_type pos);

   Pengembalian: *(begin() + pos)jika pos < size(), referensi ke objek jenis CharTdengan nilai CharT(); nilai referensi tidak boleh dimodifikasi.

---

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

   Pengembalian: Penunjuk p sedemikian rupa p + i == &operator[](i)untuk masing-masing idalam [0,size()].

Ada beberapa cara yang memungkinkan untuk mendapatkan pointer karakter non const.

1. Gunakan penyimpanan C ++ 11 yang berdekatan

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

Pro

• Sederhana dan pendek
• Cepat (hanya metode tanpa melibatkan salinan)

Cons

• Final '\0'tidak boleh diubah / tidak harus bagian dari memori non-const.

2. Gunakan std::vector<CharT>

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

Pro

• Sederhana
• Penanganan memori otomatis
• Dinamis

Cons

• Membutuhkan salinan string

3. Gunakan std::array<CharT, N>jika Nkompilasi waktu konstan (dan cukup kecil)

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

Pro

• Sederhana
• Penanganan memori tumpukan

Cons

• Statis
• Membutuhkan salinan string

4. Alokasi memori mentah dengan penghapusan penyimpanan otomatis

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

Pro

• Jejak memori kecil
• Penghapusan otomatis
• Sederhana

Cons

• Membutuhkan salinan string
• Statis (penggunaan dinamis membutuhkan lebih banyak kode)
• Lebih sedikit fitur daripada vektor atau array

5. Alokasi memori mentah dengan penanganan manual

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

Pro

• 'Kontrol' maksimum

Menipu

• Membutuhkan salinan string
• Kewajiban / kerentanan maksimum untuk kesalahan
• Kompleks

Saya bekerja dengan API dengan banyak fungsi dapatkan sebagai input a char*.

Saya telah membuat kelas kecil untuk menghadapi masalah semacam ini, saya telah mengimplementasikan idiom RAII.

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

Dan Anda dapat menggunakannya sebagai:

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

Saya telah memanggil kelas DeepStringkarena membuat salinan yang dalam dan unik ( DeepStringtidak dapat disalin) dari string yang ada.

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

Lihat saja ini:

string str1("stackoverflow");
const char * str2 = str1.c_str();

Namun, perhatikan bahwa ini akan mengembalikan a const char *.

Untuk a char *, gunakan strcpyuntuk menyalinnya ke chararray lain .

Coba ini

std::string s(reinterpret_cast<const char *>(Data), Size);