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

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()).unwrap();
    let boxed = c_string.into_boxed_c_str();
    assert_eq!(boxed.into_c_string(), CString::new("foo").unwrap());Run

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

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

### `impl Debug for CStr`
1.3.0
[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`
[src]

Formats the value using the given formatter.

### `impl<'a> Default for &'a CStr`
1.10.0
[src]

#### `fn default() -> &'a CStr`
[src]

Returns the "default value" for a type. Read more

### `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

### `impl AsRef<CStr> for CStr`
1.7.0
[src]

#### `fn as_ref(&self) -> &CStr`
[src]

Performs the conversion.

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)