How to convert a C-style char* to std::string in C ? (And Vice Versa)

C-style char can be safely converted to std::string, but when converting std::string to const char, you need to pay attention to the life cycle: use c_str() or data() to obtain a read-only pointer, the validity period is only when the string object exists and has not been modified; be careful when obtaining a writable char*, it is recommended to use vector or resize to obtain the address, and disable const_cast.

To convert a C-style char* to std::string , just pass the pointer to the std::string constructor. To go the other way, use .c_str() or .data() — but be careful with lifetime and mutability.

Converting char* → std::string

This is straightforward and safe as long as the char* points to a valid null-terminated string.

• If the pointer is non-null and points to a C-string: std::string s(p);
• If the pointer might be null, check first: std::string s(p ? p : "");
• If you need a substring or know the length (eg, no null terminator), use the two-argument constructor: std::string s(p, len);

Converting std::string → const char*

std::string provides .c_str() (guaranteed null-terminated) and .data() (same as .c_str() since C 11 for null-terminated strings). Both return const char* .

• Use s.c_str() when interfacing with C APIs that expect null-terminated strings
• The returned pointer is only valid while the string object lives and isn't modified — don't store it beyond that
• Never write through .c_str() ; it's read-only . For mutable access, use &s[0] or s.data() only if you're certain the string is not empty and you won't reallocate it

Getting a mutable char* from std::string

There's no direct, safe way to get a writable char* because std::string manages its own memory. But you can work around it carefully:

• For temporary mutation: std::vector<char> buf(s.begin(), s.end()); buf.push_back('\0'); char* p = &amp;buf[0];</char>
• Or use s.resize(n); char* p = &s[0]; — valid only if you don't change size afterward, and only in C 11 and later
• Avoid legacy patterns like const_cast<char> (s.c_str())</char> — undefined behavior if you write to it

Common pitfalls to avoid

These mistakes cause crashes or subtle bugs:

• Storing the result of .c_str() and using it after the string is destroyed or reassigned
• Passing .c_str() to a function that stores the pointer for later use without copying
• Assuming .data() is null-terminated before C 11 (it wasn't guaranteed)
• Using an uninitialized or dangling char* in the conversion — always validate input

The above is the detailed content of How to convert a C-style char* to std::string in C ? (And Vice Versa). For more information, please follow other related articles on the PHP Chinese website!