Struct CStr 

pub struct CStr { /* private fields */ }

A dynamically-sized view of a C string.

The type &CStr represents a reference to a borrowed nul-terminated array of bytes. It can be constructed safely from a &[u8] slice, or unsafely from a raw *const c_char. It can be expressed as a literal in the form c"Hello world".

The &CStr can then be converted to a Rust &str by performing UTF-8 validation, or into an owned CString.

&CStr is to CString as &str is to String: the former in each pair are borrowing references; the latter are owned strings.

Note that this structure does not have a guaranteed layout (the repr(transparent) notwithstanding) and should not be placed in the signatures of FFI functions. Instead, safe wrappers of FFI functions may leverage [CStr::as_ptr] and the unsafe CStr::from_ptr constructor to provide a safe interface to other consumers.

Examples

Inspecting a foreign C string:

use std::ffi::CStr;
use std::os::raw::c_char;

extern "C" { fn my_string() -> *const c_char; }

unsafe {
    let slice = CStr::from_ptr(my_string());
    println!("string buffer size without nul terminator: {}", slice.to_bytes().len());
}

Passing a Rust-originating C string:

use std::ffi::CStr;
use std::os::raw::c_char;

fn work(data: &CStr) {
    unsafe extern "C" fn work_with(s: *const c_char) {}
    unsafe { work_with(data.as_ptr()) }
}

let s = c"Hello world!";
work(&s);

Converting a foreign C string into a Rust String:

use std::ffi::CStr;
use std::os::raw::c_char;

extern "C" { fn my_string() -> *const c_char; }

fn my_string_safe() -> String {
    let cstr = unsafe { CStr::from_ptr(my_string()) };
    // Get a copy-on-write Cow<'_, str>, then extract the
    // allocated String (or allocate a fresh one if needed).
    cstr.to_string_lossy().into_owned()
}

println!("string: {}", my_string_safe());

Implementations

impl CStr

pub const unsafe fn from_ptr<'a>(ptr: *const c_char) -> &'a CStr

Wraps a raw C string with a safe C string wrapper.

This function will wrap the provided ptr with a CStr wrapper, which allows inspection and interoperation of non-owned C strings. The total size of the terminated buffer must be smaller than isize::MAX bytes in memory (a restriction from slice::from_raw_parts).

Safety

• The memory pointed to by ptr must contain a valid nul terminator at the end of the string.

• ptr must be valid for reads of bytes up to and including the nul terminator. This means in particular:

  • The entire memory range of this CStr must be contained within a single allocation!
  • ptr must be non-null even for a zero-length cstr.

• The memory referenced by the returned CStr must not be mutated for the duration of lifetime 'a.

• The nul terminator must be within isize::MAX from ptr

Note: This operation is intended to be a 0-cost cast but it is currently implemented with an up-front calculation of the length of the string. This is not guaranteed to always be the case.

Caveat

The lifetime for the returned slice is inferred from its usage. To prevent accidental misuse, it’s suggested to tie the lifetime to whichever source lifetime is safe in the context, such as by providing a helper function taking the lifetime of a host value for the slice, or by explicit annotation.

Examples

use std::ffi::{c_char, CStr};

fn my_string() -> *const c_char {
    c"hello".as_ptr()
}

unsafe {
    let slice = CStr::from_ptr(my_string());
    assert_eq!(slice.to_str().unwrap(), "hello");
}

use std::ffi::{c_char, CStr};

const HELLO_PTR: *const c_char = {
    const BYTES: &[u8] = b"Hello, world!\0";
    BYTES.as_ptr().cast()
};
const HELLO: &CStr = unsafe { CStr::from_ptr(HELLO_PTR) };

assert_eq!(c"Hello, world!", HELLO);

pub const fn from_bytes_with_nul( bytes: &[u8], ) -> Result<&Self, FromBytesWithNulError>

Creates a C string wrapper from a byte slice with exactly one nul terminator.

This function will cast the provided bytes to a CStr wrapper after ensuring that the byte slice is nul-terminated and does not contain any interior nul bytes.

If the nul byte may not be at the end, [CStr::from_bytes_until_nul] can be used instead.

Examples

use std::ffi::CStr;

let cstr = CStr::from_bytes_with_nul(b"hello\0");
assert_eq!(cstr, Ok(c"hello"));

Creating a CStr without a trailing nul terminator is an error:

use std::ffi::{CStr, FromBytesWithNulError};

let cstr = CStr::from_bytes_with_nul(b"hello");
assert_eq!(cstr, Err(FromBytesWithNulError::NotNulTerminated));

Creating a CStr with an interior nul byte is an error:

use std::ffi::{CStr, FromBytesWithNulError};

let cstr = CStr::from_bytes_with_nul(b"he\0llo\0");
assert_eq!(cstr, Err(FromBytesWithNulError::InteriorNul { position: 2 }));

pub const unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &CStr

Unsafely creates a C string wrapper from a byte slice.

This function will cast the provided bytes to a CStr wrapper without performing any sanity checks.

Safety

The provided slice must be nul-terminated and not contain any interior nul bytes.

Examples

use std::ffi::CStr;

let bytes = b"Hello world!\0";

let cstr = unsafe { CStr::from_bytes_with_nul_unchecked(bytes) };
assert_eq!(cstr.to_bytes_with_nul(), bytes);

pub const fn to_bytes_with_nul(&self) -> &[u8]

Converts this C string to a byte slice containing the trailing 0 byte.

This function is the equivalent of [CStr::to_bytes] except that it will retain the trailing nul terminator instead of chopping it off.

Note: This method is currently implemented as a 0-cost cast, but it is planned to alter its definition in the future to perform the length calculation whenever this method is called.

Examples

assert_eq!(c"foo".to_bytes_with_nul(), b"foo\0");