std :: karakter dizisi *

Bir std :: string bir char * veya char [] veri türüne dönüştürmek istiyorum .

std::string str = "string";
char* chr = str;

Sonuçlar: “hata: 'std :: string' öğesini 'char' haline dönüştüremiyor ...” .

Bunu yapmak için hangi yöntemler var?

Otomatik olarak dönüştürülmez (şükürler olsun). c_str()C dize sürümünü almak için yöntemi kullanmanız gerekir.

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

Bir const char *; tarafından döndürülen C stili dizeyi değiştirmenize izin verilmiyor c_str(). İşlemek istiyorsanız önce kopyalamanız gerekir:

std::string str = "string";
char *cstr = new char[str.length() + 1];
strcpy(cstr, str.c_str());
// do stuff
delete [] cstr;

Veya modern C ++ ile:

std::vector<char> cstr(str.c_str(), str.c_str() + str.size() + 1);

Burada ve burada daha fazla ayrıntı ama kullanabilirsiniz

string str = "some string" ;
char *cstr = &str[0];

Bir c ++ 's dize içeriğinin değiştirilebilir bir ham kopya gerekir, o zaman bunu yapmak:

std::string str = "string";
char* chr = strdup(str.c_str());

ve sonra:

free(chr); 

Öyleyse neden başka biri gibi std :: vector veya new [] ile uğraşmıyorum? Çünkü ben bir değişken C tarzı ham kömürü gerektiğinde * dize, o zaman dize değiştirir ve C kodu malloc () (strdup kullanımlar malloc) olan serbest () ve ayırır ile malzeme kaldırır C kodu aramak istiyorum çünkü . Bazı fonksiyon X'e benim ham dize geçirirseniz Yani C ile yazılmış bu olabilir o kadar yığın tahsis ettiğini 's argüman üzerinde bir sınırlama var (örneğin fonksiyon parametreye realloc aramak istersin ise). Ancak (bazı kullanıcı tarafından yeniden tanımlanmış) yeni [] ile ayrılmış bir argüman beklemesi pek olası değildir!

_{(Bu yanıt yalnızca C ++ 98 için geçerlidir.)}

Lütfen, çiğ kullanmayın char*.

std::string str = "string";
std::vector<char> chars(str.c_str(), str.c_str() + str.size() + 1u);
// use &chars[0] as a char*

• Yalnızca aynı içeriği temsil eden bir C stili dize istiyorsanız:

  char const* ca = str.c_str();

• Yeni içeriğe sahip bir C stili dize istiyorsanız, derleme zamanında dize boyutunu bilmediğinizden biri dinamik ayırmadır:

  char* ca = new char[str.size()+1];
  std::copy(str.begin(), str.end(), ca);
  ca[str.size()] = '\0';

  Daha delete[]sonra unutmayın .

• Bunun yerine statik olarak ayrılmış, sınırlı uzunlukta bir dizi istiyorsanız:

  size_t const MAX = 80; // maximum number of chars
  char ca[MAX] = {};
  std::copy(str.begin(), (str.size() >= MAX ? str.begin() + MAX : str.end()), ca);

std::stringbunu yapmanın genellikle bir tasarım kokusu olmasının basit bir nedeni için örtük olarak bu türlere dönüşmez. Gerçekten emin ol ihtiyacınız .

Kesinlikle bir ihtiyacınız varsa char*, en iyi yol muhtemelen:

vector<char> v(str.begin(), str.end());
char* ca = &v[0]; // pointer to start of vector

Bu, bobobobo'nun cevabına bir yorum olarak daha iyi olurdu, ancak bunun için bir temsilcim yok. Aynı şeyi daha iyi uygulamalarla başarır.

Diğer cevaplar kullanışlı olmasına rağmen hiç dönüştürmek gerekiyorsa, std::stringhiç char*Kat olmadan açıkça, const_castsenin arkadaşın.

std::string str = "string";
char* chr = const_cast<char*>(str.c_str());

Bu edeceği Not değil size verilerin bir kopyasını vermek; size dize için bir işaretçi verecektir. Böylece, öğesinin bir öğesini değiştirirseniz chr, değiştirirsiniz str.

Giriş olarak geçmek için sadece bir C stili dizeye ihtiyacınız olduğunu varsayarsak:

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

Kesinlikle bilgiç olmak için, "std :: string'i bir char * veya char [] veri türüne dönüştüremezsiniz."

Diğer yanıtların gösterdiği gibi, std :: dizesinin içeriğini bir char dizisine kopyalayabilir veya "C stili" nden erişebilmeniz için std :: dizesinin içeriğine const char * yapabilirsiniz. .

Std :: string'in içeriğini değiştirmeye çalışıyorsanız, std :: string tipi, muhtemelen yapmanız gereken her şeyi yapmak için tüm yöntemlere sahiptir.

Char * alan bir işleve geçirmeye çalışıyorsanız, std :: string :: c_str () vardır.

İşte bir daha sağlam versiyonu Protocol Buffer

char* string_as_array(string* str)
{
    return str->empty() ? NULL : &*str->begin();
}

// test codes
std::string mystr("you are here");
char* pstr = string_as_array(&mystr);
cout << pstr << endl; // you are here

OOP tarzında dönüşüm

converter.hpp

class StringConverter {
    public: static char * strToChar(std::string str);
};

converter.cpp

char * StringConverter::strToChar(std::string str)
{
    return (char*)str.c_str();
}

kullanım

StringConverter::strToChar("converted string")

Bütünlük uğruna unutma std::string::copy().

std::string str = "string";
const size_t MAX = 80;
char chrs[MAX];

str.copy(chrs, MAX);

std::string::copy()NUL sonlanmaz. C string işlevlerinde kullanmak için bir NUL sonlandırıcı sağlamanız gerekiyorsa:

std::string str = "string";
const size_t MAX = 80;
char chrs[MAX];

memset(chrs, '\0', MAX);
str.copy(chrs, MAX-1);

Yineleyiciyi kullanarak yapabilirsiniz.

std::string str = "string";
std::string::iterator p=str.begin();
char* chr = &(*p);

İyi şanslar.

Unique_ptr kullanarak orlp'nin char * yanıtının güvenli bir sürümü:

std::string str = "string";
auto cstr = std::make_unique<char[]>(str.length() + 1);
strcpy(cstr.get(), str.c_str());

Bir elde etmek için const char *, bir gelen std::stringkullanımı c_str()elemanı işlevi:

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

Olmayan bir const elde etmek için char *bir mesafede std::stringkullanabilirsiniz data()C ++ 17 yana const olmayan işaretçi döndürür üye işlevi:

std::string str = "string";
char* chr = str.data();

Dilin eski sürümlerinde, dizeyi sabit olmayan bir işaretçi elde edilebilecek bir vektöre kopyalamak için aralık yapısını kullanabilirsiniz:

std::string str = "string";
std::vector<char> str_copy(str.c_str(), str.c_str() + str.size() + 1);
char* chr = str_copy.data();

Ancak bunun içerdiği dizeyi değiştirmenize izin vermeyeceğine dikkat edin str, yalnızca kopyanın verileri bu şekilde değiştirilebilir. Dilin eski sürümlerinde c_str()burada kullanılması özellikle önemlidir, çünkü o std::stringzamana kadar çağrılıncaya kadar boş sonlandırılacağı garanti edilmemiştir c_str().

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

Alternatif olarak, aşağıda gösterildiği gibi yazılabilir bir karakter * elde etmek için vektörleri kullanabilirsiniz;

//this handles memory manipulations and is more convenient
string str;
vector <char> writable (str.begin (), str.end) ;
writable .push_back ('\0'); 
char* cstring = &writable[0] //or &*writable.begin () 

//Goodluck  

Bu da işe yarayacak

std::string s;
std::cout<<"Enter the String";
std::getline(std::cin, s);
char *a=new char[s.size()+1];
a[s.size()]=0;
memcpy(a,s.c_str(),s.size());
std::cout<<a;