[−][src]Struct thin_cstr::CStr
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 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 { 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 { fn work_with(data: *const c_char); } unsafe { work_with(data.as_ptr()) } } let s = CString::new("data data data data").unwrap(); work(&s);
Converting a foreign C string into a Rust String
:
use std::ffi::CStr; use std::os::raw::c_char; extern { 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());
Methods
impl CStr
[src]
pub unsafe fn from_ptr<'a>(ptr: *const c_char) -> &'a CStr
[src]
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. 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.
Note: This operation is a 0-cost cast but in older version of Rust it was implemented with an up-front calculation of the length of the string.
Examples
use std::ffi::CStr; use std::os::raw::c_char; extern { 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>
[src]
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 c_str = CStr::from_bytes_with_nul(b"hello"); assert!(c_str.is_err());
Creating a CStr
with an interior nul byte is an error:
use std::ffi::CStr; let c_str = CStr::from_bytes_with_nul(b"he\0llo\0"); assert!(c_str.is_err());
pub unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &CStr
[src]
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").unwrap(); let cstr = CStr::from_bytes_with_nul_unchecked(cstring.to_bytes_with_nul()); assert_eq!(cstr, &*cstring); }
pub fn as_ptr(&self) -> *const c_char
[src]
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
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").unwrap().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").unwrap().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").unwrap(); 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]
[src]
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 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 c_str = CStr::from_bytes_with_nul(b"foo\0").unwrap(); assert_eq!(c_str.to_bytes(), b"foo");
pub fn to_bytes_with_nul(&self) -> &[u8]
[src]
Converts this C string to a byte slice containing the trailing 0 byte.
This function is the equivalent of to_bytes
except that it will retain
the trailing nul terminator instead of chopping it off.
Note: This method will perform the length calculation whenever it is called.
Examples
use std::ffi::CStr; let c_str = CStr::from_bytes_with_nul(b"foo\0").unwrap(); assert_eq!(c_str.to_bytes_with_nul(), b"foo\0");
pub fn to_str(&self) -> Result<&str, Utf8Error>
[src]
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.
Note: This method is currently implemented to check for validity after a 0-cost cast, but it is planned to alter its definition in the future to perform the length calculation in addition to the UTF-8 check whenever this method is called.
Examples
use std::ffi::CStr; let c_str = CStr::from_bytes_with_nul(b"foo\0").unwrap(); assert_eq!(c_str.to_str(), Ok("foo"));
pub fn to_string_lossy(&self) -> Cow<str>
[src]
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 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.
Note: This method will perform the length calculation in addition to the UTF-8 check whenever this method is called.
Examples
Calling to_string_lossy
on a CStr
containing valid UTF-8:
use std::borrow::Cow; use std::ffi::CStr; let c_str = CStr::from_bytes_with_nul(b"Hello World\0").unwrap(); assert_eq!(c_str.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 c_str = CStr::from_bytes_with_nul(b"Hello \xF0\x90\x80World\0").unwrap(); assert_eq!( c_str.to_string_lossy(), Cow::Owned(String::from("Hello �World")) as Cow<str> );
pub fn into_c_string(self: Box<CStr>) -> CString
[src]
Converts a Box
<CStr>
into a CString
without copying or allocating.
Note: Although this method will not copy or allocate bytes, it will still perform the length calculation.
Examples
use std::ffi::CString; let c_string = CString::new(b"foo".to_vec()).unwrap(); let boxed = c_string.into_boxed_c_str(); assert_eq!(boxed.into_c_string(), CString::new("foo").unwrap());
Trait Implementations
impl AsRef<CStr> for CStr
[src]
impl AsRef<CStr> for CString
[src]
impl Borrow<CStr> for CString
[src]
impl Debug for CStr
[src]
impl<'a> Default for &'a CStr
[src]
impl Eq for CStr
[src]
impl<'a> From<&'a CStr> for Box<CStr>
[src]
impl<'a> From<&'a CStr> for CString
[src]
impl Hash for CStr
[src]
fn hash<H: Hasher>(&self, hasher: &mut H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl Ord for CStr
[src]
fn cmp(&self, other: &CStr) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl PartialEq<CStr> for CStr
[src]
impl PartialOrd<CStr> for CStr
[src]
fn partial_cmp(&self, other: &CStr) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl RefUnwindSafe for CStr
[src]
impl Send for CStr
[src]
impl Sync for CStr
[src]
impl ToOwned for CStr
[src]
type Owned = CString
The resulting type after obtaining ownership.