Struct std::ffi::CStr 1.0.0
[−]
[src]
pub struct CStr { /* fields omitted */ }
Representation of a borrowed C string.
This dynamically sized type is only safely constructed via a borrowed
version of an instance of CString
. This type can be constructed from a raw
C string as well and represents a C string borrowed from another location.
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 length: {}", slice.to_bytes().len()); }Run
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);Run
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());Run
Methods
impl CStr
[src]
unsafe fn from_ptr<'a>(ptr: *const c_char) -> &'a CStr
[src]
Casts a raw C string to a safe C string wrapper.
This function will cast the provided ptr
to the 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 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 { fn my_string() -> *const c_char; } unsafe { let slice = CStr::from_ptr(my_string()); println!("string returned: {}", slice.to_str().unwrap()); }Run
fn from_bytes_with_nul(bytes: &[u8]) -> Result<&CStr, FromBytesWithNulError>
1.10.0[src]
Creates a C string wrapper from a byte slice.
This function will cast the provided bytes
to a CStr
wrapper after
ensuring that it is null 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());Run
Creating a CStr
without a trailing nul byte is an error:
use std::ffi::CStr; let c_str = CStr::from_bytes_with_nul(b"hello"); assert!(c_str.is_err());Run
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());Run
unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &CStr
1.10.0[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 null 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); }Run
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; }Run
This happens because the pointer returned by as_ptr
does not carry any
lifetime information and the string is deallocated immediately after
the CString::new("Hello").unwrap().as_ptr()
expression is evaluated.
To fix the problem, bind the string 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; }Run
fn to_bytes(&self) -> &[u8]
[src]
Converts this C string to a byte slice.
This function will calculate the length of this string (which normally
requires a linear amount of work to be done) and then return the
resulting slice of u8
elements.
The returned slice will not contain the trailing nul 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");Run
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 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 c_str = CStr::from_bytes_with_nul(b"foo\0").unwrap(); assert_eq!(c_str.to_bytes_with_nul(), b"foo\0");Run
fn to_str(&self) -> Result<&str, Utf8Error>
1.4.0[src]
Yields a &str
slice if the CStr
contains valid UTF-8.
This function will calculate the length of this string and check for
UTF-8 validity, and then return the &str
if it's valid.
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"));Run
fn to_string_lossy(&self) -> Cow<str>
1.4.0[src]
Converts a CStr
into a Cow
<
str
>
.
This function will calculate the length of this string (which normally
requires a linear amount of work to be done) and then return the
resulting slice as a Cow
<
str
>
, replacing any invalid UTF-8 sequences
with U+FFFD REPLACEMENT CHARACTER
.
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
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"));Run
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> );Run
fn into_c_string(self: Box<CStr>) -> CString
1.20.0[src]
Trait Implementations
impl Hash for CStr
[src]
fn hash<__H: Hasher>(&self, __arg_0: &mut __H)
[src]
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl Debug for CStr
1.3.0[src]
impl<'a> Default for &'a CStr
1.10.0[src]
impl PartialEq for CStr
[src]
fn eq(&self, other: &CStr) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
[src]
This method tests for !=
.
impl Eq for CStr
[src]
impl PartialOrd for CStr
[src]
fn partial_cmp(&self, other: &CStr) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
[src]
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
[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl Ord for CStr
[src]
fn cmp(&self, other: &CStr) -> Ordering
[src]
This method returns an Ordering
between self
and other
. Read more
fn max(self, other: Self) -> Self
1.21.0[src]
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
1.21.0[src]
Compares and returns the minimum of two values. Read more
impl ToOwned for CStr
1.3.0[src]
type Owned = CString
fn to_owned(&self) -> CString
[src]
Creates owned data from borrowed data, usually by cloning. Read more
fn clone_into(&self, target: &mut Self::Owned)
[src]
🔬 This is a nightly-only experimental API. (toowned_clone_into
#41263)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more