ฉันต้องการที่จะแปลงมาตรฐาน :: สตริงเป็นchar *หรือถ่าน []ชนิดข้อมูล

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

ผลการค้นหาใน: “ข้อผิดพลาด: ไม่สามารถแปลง 'มาตรฐาน :: สตริง' เป็น 'ถ่าน' ...”

มีวิธีใดบ้างในการทำเช่นนี้?

ตอบ

มันจะไม่แปลงโดยอัตโนมัติ (ขอบคุณพระเจ้า) คุณจะต้องใช้วิธีนี้c_str()เพื่อรับเวอร์ชันสตริง C

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

โปรดทราบว่าจะส่งกลับconst char *; คุณไม่ได้รับอนุญาตให้เปลี่ยนสตริงสไตล์ C ที่ส่งคืนโดยc_str(). หากคุณต้องการดำเนินการ คุณจะต้องคัดลอกก่อน:

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

หรือใน C ++ สมัยใหม่:

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

รายละเอียดเพิ่มเติม ที่นี่และที่นี่แต่คุณสามารถใช้

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

หากฉันต้องการสำเนาดิบที่ไม่แน่นอนของเนื้อหาสตริงของ c++ ฉันจะทำสิ่งนี้:

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

และหลังจากนั้น:

free(chr); 

เหตุใดฉันจึงไม่เล่นซอกับ std::vector หรือ new[] เหมือนคนอื่น เพราะเมื่อฉันต้องไม่แน่นอนแบบ C ถ่านดิบ * สตริงแล้วเพราะผมต้องการที่จะเรียกรหัส C ซึ่งการเปลี่ยนแปลงสตริงและรหัส C deallocates สิ่งที่มีฟรี () และจัดสรรกับ malloc () (ใช้ strdup malloc) ดังนั้นถ้าฉันผ่านสตริงดิบของฉันไปที่ฟังก์ชั่นบางอย่าง X เขียนใน Cมันอาจมีข้อ จำกัด ที่เป็นของการโต้แย้งว่าจะมีการจัดสรรในกอง (ตัวอย่างเช่นถ้าฟังก์ชันอาจต้องการที่จะเรียก realloc ในพารามิเตอร์) แต่ไม่น่าเป็นไปได้สูงที่คาดว่าจะมีการโต้แย้งที่จัดสรรด้วย (กำหนดโดยผู้ใช้ใหม่บางส่วน) new[]!

(คำตอบนี้ใช้กับ C++98 เท่านั้น)

char*โปรดอย่าใช้ดิบ

std::string str = "string";
std::vector<char> chars(str.c_str(), str.c_str() + str.size() + 1u);
// use &chars[0] as a char*
  • หากคุณต้องการเพียงสตริงสไตล์ C ที่แสดงเนื้อหาเดียวกัน:

    char const* ca = str.c_str();
    
  • หากคุณต้องการสตริงสไตล์ C ที่มีเนื้อหาใหม่วิธีหนึ่ง (โดยที่คุณไม่ทราบขนาดสตริง ณ เวลาคอมไพล์) คือการจัดสรรแบบไดนามิก:

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

    delete[]ทีหลังก็อย่าลืม

  • หากคุณต้องการอาร์เรย์ที่มีความยาวจำกัดที่จัดสรรแบบสแตติกแทน:

    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::stringไม่ได้แปลงเป็นประเภทเหล่านี้โดยปริยายด้วยเหตุผลง่ายๆ ที่จำเป็นต้องทำเช่นนี้มักจะมีกลิ่นการออกแบบ ตรวจสอบให้แน่ใจว่าคุณจำเป็นต้องใช้มันจริงๆ

หากคุณแน่นอนต้องchar*ที่ดีที่สุดวิธีที่น่าจะเป็น:

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

จะดีกว่าถ้าแสดงความคิดเห็นในคำตอบของ bobobobo แต่ฉันไม่มีตัวแทนสำหรับเรื่องนั้น มันสำเร็จในสิ่งเดียวกัน แต่ด้วยแนวทางปฏิบัติที่ดีกว่า

แม้ว่าคำตอบอื่น ๆ จะมีประโยชน์ แต่ถ้าคุณต้องการแปลงstd::stringเป็นchar*อย่างชัดเจนโดยไม่มีข้อผูกมัด ให้const_castเป็นเพื่อนกับคุณ

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

โปรดทราบว่าการดำเนินการนี้จะไม่ให้สำเนาข้อมูลแก่คุณ มันจะให้ตัวชี้ไปที่สตริง ดังนั้นหากคุณปรับเปลี่ยนองค์ประกอบของคุณจะปรับเปลี่ยนchrstr

สมมติว่าคุณแค่ต้องการสตริงสไตล์ C เพื่อส่งผ่านเป็นอินพุต:

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

ในการรับ a const char *จากการstd::stringใช้c_str()ฟังก์ชันสมาชิก:

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

ในการรับค่า non-const char *จาก a std::stringคุณสามารถใช้data()ฟังก์ชันสมาชิกซึ่งส่งคืนตัวชี้ที่ไม่ใช่ const ตั้งแต่ C++17 :

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

สำหรับภาษาเวอร์ชันเก่า คุณสามารถใช้การสร้างช่วงเพื่อคัดลอกสตริงลงในเวกเตอร์ซึ่งสามารถรับตัวชี้แบบ non-const ได้:

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

แต่ระวังว่าสิ่งนี้จะไม่อนุญาตให้คุณแก้ไขสตริงที่มีอยู่ในstrเฉพาะข้อมูลของสำเนาเท่านั้นที่สามารถเปลี่ยนแปลงได้ด้วยวิธีนี้ โปรดทราบว่าการใช้ที่นี่เป็นสิ่งสำคัญเป็นพิเศษในภาษารุ่นเก่า เพราะในสมัยc_str()นั้นstd::stringไม่รับประกันว่าจะถูกยกเลิกเป็นโมฆะจนกว่าจะc_str()มีการเรียก

ในการพูดอวดดีอย่างเคร่งครัด คุณไม่สามารถ "แปลง std::string เป็น char* หรือ char[] data type"

ตามที่แสดงคำตอบอื่น ๆ คุณสามารถคัดลอกเนื้อหาของ std::string ไปยังอาร์เรย์ char หรือสร้าง const char* ไปยังเนื้อหาของ std::string เพื่อให้คุณสามารถเข้าถึงได้ใน "สไตล์ C" .

หากคุณกำลังพยายามเปลี่ยนเนื้อหาของ std::string ประเภท std::string มีวิธีการทั้งหมดในการทำสิ่งที่คุณต้องทำ

หากคุณกำลังพยายามส่งต่อไปยังฟังก์ชันบางอย่างที่ใช้อักขระ std::string::c_str()

นี่เป็นอีกหนึ่งเวอร์ชั่นที่แข็งแกร่งจาก 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

converter.hpp

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

converter.cpp

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

การใช้งาน

StringConverter::strToChar("converted string")

std::string::copy()เพื่อประโยชน์ครบถ้วนไม่ลืม

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

str.copy(chrs, MAX);

std::string::copy()ไม่สิ้นสุด NUL หากคุณต้องการตรวจสอบให้แน่ใจว่าเทอร์มินัล NUL สำหรับใช้ในฟังก์ชันสตริง C:

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

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

คุณสามารถทำให้มันใช้ตัววนซ้ำ

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

ขอให้โชคดี.

คำตอบ char* ของ orlp รุ่นที่ปลอดภัยโดยใช้ unique_ptr:

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

หรือ คุณสามารถใช้เวกเตอร์เพื่อรับอักขระที่เขียนได้* ดังที่แสดงด้านล่าง

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

สิ่งนี้จะได้ผลเช่นกัน

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;  

ร่างกายไม่เคยพูดถึง sprintf?

std::string s;
char * c;
sprintf(c, "%s", s.c_str());