Struct std::ffi::CStr
pub struct CStr { /* fields omitted */ }
Representation of a borrowed C string.
This type represents a borrowed reference to a nul-terminated array of bytes. It can be constructed safely from a &[
u8
]
slice, or unsafely from a raw *const c_char
. It 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 borrowed references; the latter are owned strings.
Note that this structure is not repr(C)
and is not recommended to be placed in the signatures of FFI functions. Instead, safe wrappers of FFI functions may leverage 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::{CString, CStr}; use std::os::raw::c_char; fn work(data: &CStr) { extern "C" { fn work_with(data: *const c_char); } unsafe { work_with(data.as_ptr()) } } let s = CString::new("data data data data").expect("CString::new failed"); 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 { unsafe { CStr::from_ptr(my_string()).to_string_lossy().into_owned() } } println!("string: {}", my_string_safe());
Implementations
impl CStr
pub 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 raw C string must be smaller than isize::MAX
bytes in memory due to calling the slice::from_raw_parts
function. This method is unsafe for a number of reasons:
- There is no guarantee to the validity of
ptr
. - The returned lifetime is not guaranteed to be the actual lifetime of
ptr
. - There is no guarantee that the memory pointed to by
ptr
contains a valid nul terminator byte at the end of the string. - It is not guaranteed that the memory pointed by
ptr
won’t change before theCStr
has been destroyed.
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.
Examples
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 returned: {}", slice.to_str().unwrap()); }
pub fn from_bytes_with_nul(bytes: &[u8]) -> Result<&CStr, FromBytesWithNulError>
Creates a C string wrapper from a byte slice.
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.
Examples
use std::ffi::CStr; let cstr = CStr::from_bytes_with_nul(b"hello\0"); assert!(cstr.is_ok());
Creating a CStr
without a trailing nul terminator is an error:
use std::ffi::CStr; let cstr = CStr::from_bytes_with_nul(b"hello"); assert!(cstr.is_err());
Creating a CStr
with an interior nul byte is an error:
use std::ffi::CStr; let cstr = CStr::from_bytes_with_nul(b"he\0llo\0"); assert!(cstr.is_err());
pub 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. The provided slice must be nul-terminated and not contain any interior nul bytes.
Examples
use std::ffi::{CStr, CString}; unsafe { let cstring = CString::new("hello").expect("CString::new failed"); let cstr = CStr::from_bytes_with_nul_unchecked(cstring.to_bytes_with_nul()); assert_eq!(cstr, &*cstring); }
pub const fn as_ptr(&self) -> *const c_char
Returns the inner pointer to this C string.
The returned pointer will be valid for as long as self
is, and points to a contiguous region of memory terminated with a 0 byte to represent the end of the string.
WARNING
The returned pointer is read-only; writing to it (including passing it to C code that writes to it) causes undefined behavior.
It is your responsibility to make sure that the underlying memory is not freed too early. For example, the following code will cause undefined behavior when ptr
is used inside the unsafe
block:
use std::ffi::CString; let ptr = CString::new("Hello").expect("CString::new failed").as_ptr(); unsafe { // `ptr` is dangling *ptr; }
This happens because the pointer returned by as_ptr
does not carry any lifetime information and the CString
is deallocated immediately after the CString::new("Hello").expect("CString::new failed").as_ptr()
expression is evaluated. To fix the problem, bind the CString
to a local variable:
use std::ffi::CString; let hello = CString::new("Hello").expect("CString::new failed"); let ptr = hello.as_ptr(); unsafe { // `ptr` is valid because `hello` is in scope *ptr; }
This way, the lifetime of the CString
in hello
encompasses the lifetime of ptr
and the unsafe
block.
pub fn to_bytes(&self) -> &[u8]
Converts this C string to a byte slice.
The returned slice will not contain the trailing nul terminator that this C string has.
Note: This method is currently implemented as a constant-time cast, but it is planned to alter its definition in the future to perform the length calculation whenever this method is called.
Examples
use std::ffi::CStr; let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed"); assert_eq!(cstr.to_bytes(), b"foo");
pub 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
use std::ffi::CStr; let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed"); assert_eq!(cstr.to_bytes_with_nul(), b"foo\0");
pub fn to_str(&self) -> Result<&str, Utf8Error>
Yields a &str
slice if the CStr
contains valid UTF-8.
If the contents of the CStr
are valid UTF-8 data, this function will return the corresponding &str
slice. Otherwise, it will return an error with details of where UTF-8 validation failed.
Examples
use std::ffi::CStr; let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed"); assert_eq!(cstr.to_str(), Ok("foo"));
pub fn to_string_lossy(&self) -> Cow<'_, str>
Converts a CStr
into a Cow
<
str
>
.
If the contents of the CStr
are valid UTF-8 data, this function will return a Cow
::
Borrowed
(
&str
)
with the corresponding &str
slice. Otherwise, it will replace any invalid UTF-8 sequences with U+FFFD REPLACEMENT CHARACTER
and return a Cow
::
Owned
(
String
)
with the result.
Examples
Calling to_string_lossy
on a CStr
containing valid UTF-8:
use std::borrow::Cow; use std::ffi::CStr; let cstr = CStr::from_bytes_with_nul(b"Hello World\0") .expect("CStr::from_bytes_with_nul failed"); assert_eq!(cstr.to_string_lossy(), Cow::Borrowed("Hello World"));
Calling to_string_lossy
on a CStr
containing invalid UTF-8:
use std::borrow::Cow; use std::ffi::CStr; let cstr = CStr::from_bytes_with_nul(b"Hello \xF0\x90\x80World\0") .expect("CStr::from_bytes_with_nul failed"); assert_eq!( cstr.to_string_lossy(), Cow::Owned(String::from("Hello �World")) as Cow<'_, str> );
pub fn into_c_string(self: Box<CStr>) -> CString
Converts a Box
<CStr>
into a CString
without copying or allocating.
Examples
use std::ffi::CString; let c_string = CString::new(b"foo".to_vec()).expect("CString::new failed"); let boxed = c_string.into_boxed_c_str(); assert_eq!(boxed.into_c_string(), CString::new("foo").expect("CString::new failed"));
Trait Implementations
impl AsRef<CStr> for CStr
fn as_ref(&self) -> &CStr
Performs the conversion.
impl AsRef<CStr> for CString
fn as_ref(&self) -> &CStr
Performs the conversion.
impl Borrow<CStr> for CString
impl Debug for CStr
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
impl Default for &CStr
impl From<&'_ CStr> for Box<CStr>
fn from(s: &CStr) -> Box<CStr>
impl<I, A> Iterator for Box<I, A> where I: Iterator + ?Sized, A: Allocator, type Item = <I as Iterator>::Item; impl<F, A> Future for Box<F, A> where F: Future + Unpin + ?Sized, A: Allocator + 'static, type Output = <F as Future>::Output; impl<R: Read + ?Sized> Read for Box<R> impl<W: Write + ?Sized> Write for Box<W>
Performs the conversion.
impl From<&'_ CStr> for Arc<CStr>
fn from(s: &CStr) -> Arc<CStr>
Performs the conversion.
impl From<&'_ CStr> for Rc<CStr>
fn from(s: &CStr) -> Rc<CStr>
Performs the conversion.
impl From<&'_ CStr> for CString
fn from(s: &CStr) -> CString
Performs the conversion.
impl<'a> From<&'a CStr> for Cow<'a, CStr>
fn from(s: &'a CStr) -> Cow<'a, CStr>
Performs the conversion.
impl Hash for CStr
fn hash<__H: Hasher>(&self, state: &mut __H)
impl Index<RangeFrom<usize>> for CStr
type Output = CStr
The returned type after indexing.
fn index(&self, index: RangeFrom<usize>) -> &CStr
Performs the indexing (container[index]
) operation. Read more
impl Ord for CStr
fn cmp(&self, other: &CStr) -> Ordering
fn max(self, other: Self) -> Self
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
Compares and returns the minimum of two values. Read more
fn clamp(self, min: Self, max: Self) -> Self
Restrict a value to a certain interval. Read more
impl PartialEq<CStr> for CStr
fn eq(&self, other: &CStr) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<CStr> for CStr
fn partial_cmp(&self, other: &CStr) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl ToOwned for CStr
type Owned = CString
The resulting type after obtaining ownership.
fn to_owned(&self) -> CString
Creates owned data from borrowed data, usually by cloning. Read more
fn clone_into(&self, target: &mut CString)
toowned_clone_into
#41263)recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
impl Eq for CStr
Auto Trait Implementations
impl RefUnwindSafe for CStr
impl Send for CStr
impl !Sized for CStr
impl Sync for CStr
impl Unpin for CStr
impl UnwindSafe for CStr
Blanket Implementations
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/ffi/struct.CStr.html