How to Convert std::string to const char* or char* in C++

By the end of this page, you will understand how std::string stores text, how to get a C-style string from it, when to use c_str() or data(), and what to do if you truly need a writable char*. You will also learn the lifetime rules that make this conversion safe or unsafe.

In C++, std::string and C-style strings are related but not the same thing.

• std::string is a C++ string class that manages memory for you.
• A C-style string is typically a const char* or char* pointing to a null-terminated character array.

If you have a std::string, the most common way to get a read-only C-style string is:

std::string s = "hello";
const char* p = s.c_str();

c_str() returns a pointer to the string's internal character data as a const char*.

This matters because many older C libraries and some system APIs expect const char* instead of std::string.

If you need writable character data, things are different:

• You usually should not try to directly treat a std::string as a writable char* unless you understand the rules.
• If an API only reads the string, use const char* from c_str().
• If an API needs to modify the characters, create a writable buffer.

In modern C++, you may also use data():

Think of std::string as a smart container that owns and manages a text buffer for you.

A const char* from c_str() is like borrowing a read-only view of that buffer.

• You can look at it.
• You can pass it to functions that read text.
• You do not own it.
• You should not try to modify it.

A char* is different: it suggests writable memory.

That is like asking for a marker so you can edit the label directly. Sometimes the buffer can be edited safely, but only under specific rules. If you need guaranteed writable memory for another API, it is often safer to create your own separate buffer.

Read-only conversion with c_str()

#include <iostream>
#include <string>

int main() {
    std::string name = "Alice";
    const char* cstr = name.c_str();

    std::cout << cstr << '\n';
}

Use this when the function only needs to read the string.

Using data()

#include <iostream>
#include <string>

int main() {
    std::string text = "Hello";
    const char* p = text.data();

    std::cout << p << '\n';
}

In modern C++, data() is often similar to c_str() for read-only use.

Creating a writable buffer

Consider this example:

#include <iostream>
#include <string>

int main() {
    std::string s = "cat";
    const char* p = s.c_str();

    std::cout << p << '\n';
}

Step by step:

1. std::string s = "cat";

   • A C++ string object named s is created.
   • It stores the text cat and manages its own memory.

2. const char* p = s.c_str();

   • c_str() returns a pointer to the internal character data.
   • p now points to a null-terminated character sequence representing cat.
   • The pointer is const char*, so the data should not be modified through p.

This conversion is common when C++ code interacts with older APIs or libraries.

Common scenarios

• Calling C library functions such as puts, fopen, or printf
• Passing file paths to platform APIs that expect const char*
• Interfacing with third-party libraries written in C
• Logging systems that accept C-style strings
• Working with embedded systems or low-level code

Example: opening a file

#include <cstdio>
#include <string>

int main() {
    std::string filename = "data.txt";
    FILE* file = std::fopen(filename.c_str(), "r");

    if (file) {
        std::fclose(file);
    }
}

fopen expects const char*, so c_str() bridges the gap.

Example: formatting output

In real projects, developers usually follow a simple pattern:

Keep std::string as the main type

Use std::string for storing, returning, and passing text inside your C++ code.

std::string buildMessage() {
    return "Operation completed";
}

Convert only at the boundary where an API requires a C-style string.

std::string msg = buildMessage();
external_log(msg.c_str());

Use conversion at the call site

This keeps ownership clear and reduces bugs.

send_to_c_api(configPath.c_str());

Use guard clauses for empty input

if (path.empty()) {
    return;
}
legacy_open(path.c_str());

Use a separate writable buffer when mutation is required

;
buffer.();
(buffer.());

1. Modifying the result of c_str()

Broken code:

std::string s = "hello";
char* p = const_cast<char*>(s.c_str());
p[0] = 'H';

Why this is a problem:

• c_str() gives read-only access.
• Forcing it to char* with const_cast is unsafe.
• Modifying through that pointer can cause undefined behavior.

Avoid it by using a writable buffer instead.

2. Using the pointer after the string changes

Broken code:

std::string s = "hello";
const char* p = s.c_str();
s += " world";
std::cout << p << '\n';

Why this is a problem:

• Changing the string may reallocate its internal buffer.
• p may no longer point to valid data.

Fix:

std::string s = ;
s += ;
 * p = s.();
std::cout << p << ;

Quick reference

Get const char* from std::string

std::string s = "hello";
const char* p = s.c_str();

Read-only access with data()

const char* p = s.data();

Writable buffer copy

std::vector<char> buffer(s.begin(), s.end());
buffer.push_back('\0');
char* p = buffer.data();

Rules to remember

• c_str() returns const char*
• Do not modify the result of c_str()
• The pointer stays valid only while the string exists and is not modified in a way that invalidates it
• If the API only reads, use c_str()

When should I use c_str() in C++?

Use c_str() when a function expects a const char* and only needs to read the string.

Can I convert std::string directly to char*?

Not safely in the general case. If you need writable characters, create a writable buffer such as a std::vector<char> copy.

What is the difference between c_str() and data()?

c_str() is specifically for getting a C-style string. data() gives access to the underlying character buffer and may be writable for non-const strings in modern C++.

Is the pointer from c_str() always valid?

No. It is only valid while the std::string object still exists and its internal buffer has not been invalidated by certain modifications.

Can I store the result of c_str() for later use?

Only if the original std::string stays alive and unchanged in a compatible way. Otherwise, the pointer may become invalid.

• std::string — The core C++ string type involved in this conversion.
• const correctness — Important for understanding why c_str() returns const char*.
• Pointers — Needed to understand what char* and const char* actually are.
• Object lifetime — Critical for knowing when the returned pointer becomes invalid.
• std::vector<char> — A common way to build a writable character buffer.
• C-style strings — The older string representation used by many C APIs.
• Memory management — Helps explain ownership and safety when passing raw pointers.
• Function parameters — Useful for understanding why some APIs want std::string and others want const char*.