1.0.0[][src]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 from_ptr constructor to provide a safe interface to other consumers.

Examples

Inspecting a foreign C string:

This example is not tested
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());
}Run

Passing a Rust-originating C string:

This example is not tested
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").expect("CString::new failed");
work(&s);Run

Converting a foreign C string into a Rust String:

This example is not tested
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]

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.
  • It is not guaranteed that the memory pointed by ptr won't change before the CStr 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

This example is not tested
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

pub 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 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());Run

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());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

pub const unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &CStr1.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 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);
}Run

pub const 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

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;
}Run

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;
}Run

This way, the lifetime of the CString in hello encompasses the lifetime of ptr and the unsafe block.

Important traits for &'_ [u8]
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 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 c_str = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
assert_eq!(c_str.to_bytes(), b"foo");Run

Important traits for &'_ [u8]
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 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").expect("CStr::from_bytes_with_nul failed");
assert_eq!(c_str.to_bytes_with_nul(), b"foo\0");Run

pub fn to_str(&self) -> Result<&str, Utf8Error>1.4.0[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 constant-time 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").expect("CStr::from_bytes_with_nul failed");
assert_eq!(c_str.to_str(), Ok("foo"));Run

pub fn to_string_lossy(&self) -> Cow<str>1.4.0[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 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 is currently implemented to check for validity after a constant-time 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")
                 .expect("CStr::from_bytes_with_nul failed");
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")
                 .expect("CStr::from_bytes_with_nul failed");
assert_eq!(
    c_str.to_string_lossy(),
    Cow::Owned(String::from("Hello �World")) as Cow<'_, str>
);Run

pub fn into_c_string(self: Box<CStr>) -> CString1.20.0[src]

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"));Run

Trait Implementations

impl PartialEq<CStr> for CStr[src]

#[must_use] fn ne(&self, other: &Rhs) -> bool[src]

This method tests for !=.

impl Eq for CStr[src]

impl Ord for CStr[src]

fn max(self, other: Self) -> Self1.21.0[src]

Compares and returns the maximum of two values. Read more

fn min(self, other: Self) -> Self1.21.0[src]

Compares and returns the minimum of two values. Read more

fn clamp(self, min: Self, max: Self) -> Self[src]

🔬 This is a nightly-only experimental API. (clamp #44095)

Restrict a value to a certain interval. Read more

impl PartialOrd<CStr> for CStr[src]

#[must_use] fn lt(&self, other: &Rhs) -> bool[src]

This method tests less than (for self and other) and is used by the < operator. Read more

#[must_use] 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

#[must_use] fn gt(&self, other: &Rhs) -> bool[src]

This method tests greater than (for self and other) and is used by the > operator. Read more

#[must_use] 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 Hash for CStr[src]

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher
1.3.0[src]

Feeds a slice of this type into the given [Hasher]. Read more

impl Debug for CStr1.3.0[src]

impl AsRef<CStr> for CStr1.7.0[src]

impl AsRef<CStr> for CString1.7.0[src]

impl<'_> From<&'_ CStr> for Box<CStr>1.17.0[src]

impl<'a> From<&'a CStr> for Cow<'a, CStr>1.28.0[src]

impl<'_> From<&'_ CStr> for Arc<CStr>1.24.0[src]

impl<'_> From<&'_ CStr> for Rc<CStr>1.24.0[src]

impl<'_> From<&'_ CStr> for CString1.7.0[src]

impl<'_> Default for &'_ CStr1.10.0[src]

impl Borrow<CStr> for CString1.3.0[src]

impl ToOwned for CStr1.3.0[src]

type Owned = CString

The resulting type after obtaining ownership.

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

Auto Trait Implementations

impl Send for CStr

impl Sync for CStr

Blanket Implementations

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.