Struct CString 

pub struct CString<const N: usize, LenT: LenType = usize> { /* private fields */ }

A fixed capacity CString.

It stores up to N - 1 non-nul characters with a trailing nul terminator.

Implementations

impl<const N: usize, LenT: LenType> CString<N, LenT>

pub fn new() -> Self

Creates a new C-compatible string with a terminating nul byte.

use heapless::CString;

// A fixed-size `CString` that can store up to 10 characters
// including the nul terminator.
let empty = CString::<10>::new();

assert_eq!(empty.as_c_str(), c"");
assert_eq!(empty.to_str(), Ok(""));

pub unsafe fn from_bytes_with_nul_unchecked( bytes: &[u8], ) -> Result<Self, CapacityError>

Unsafely creates a CString from a byte slice.

This function will copy the provided bytes to a CString without performing any sanity checks.

The function will fail if bytes.len() > N.

Safety

The provided slice must be nul-terminated and not contain any interior nul bytes.

Examples

use heapless::CString;
let mut c_string = unsafe { CString::<7>::from_bytes_with_nul_unchecked(b"string\0").unwrap() };

assert_eq!(c_string.to_str(), Ok("string"));

pub fn from_bytes_with_nul(bytes: &[u8]) -> Result<Self, ExtendError>

Instantiates a CString copying from the giving byte slice, assuming it is nul-terminated.

Fails if the given byte slice has any interior nul byte, if the slice does not end with a nul byte, or if the byte slice can’t fit in N.

pub unsafe fn from_raw(ptr: *const c_char) -> Result<Self, ExtendError>

Builds a CString copying from a raw C string pointer.

Safety

• The memory pointed to by ptr must contain a valid nul terminator at the end of the string.
• ptr must be valid for reads of bytes up to and including the nul terminator. This means in particular:
  • The entire memory range of this CStr must be contained within a single allocated object!
  • ptr must be non-nul even for a zero-length CStr.

Example

use core::ffi::{c_char, CStr};
use heapless::CString;

const HELLO_PTR: *const c_char = {
    const BYTES: &[u8] = b"Hello, world!\0";
    BYTES.as_ptr().cast()
};

let copied = unsafe { CString::<14>::from_raw(HELLO_PTR) }.unwrap();

assert_eq!(copied.to_str(), Ok("Hello, world!"));

pub fn as_c_str(&self) -> &CStr

Converts the CString to a CStr slice.

pub fn extend_from_bytes(&mut self, bytes: &[u8]) -> Result<(), ExtendError>

Extends the CString with the given bytes.

This function fails if the CString would not have enough capacity to append the bytes or if the bytes contain an interior nul byte.

Example

use heapless::CString;

let mut c_string = CString::<10>::new();

c_string.extend_from_bytes(b"hey").unwrap();
c_string.extend_from_bytes(b" there\0").unwrap();

assert_eq!(c_string.to_str(), Ok("hey there"));

pub fn as_bytes_with_nul(&self) -> &[u8]

Returns the underlying byte slice including the trailing nul terminator.

Example

use heapless::CString;

let mut c_string = CString::<5>::new();
c_string.extend_from_bytes(b"abc").unwrap();

assert_eq!(c_string.as_bytes_with_nul(), b"abc\0");

pub fn as_bytes(&self) -> &[u8]

Returns the underlying byte slice excluding the trailing nul terminator.

Example

use heapless::CString;

let mut c_string = CString::<5>::new();
c_string.extend_from_bytes(b"abc").unwrap();

assert_eq!(c_string.as_bytes(), b"abc");

Methods from Deref<Target = CStr>

pub fn as_ptr(&self) -> *const i8

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.

The type of the returned pointer is *const c_char, and whether it’s an alias for *const i8 or *const u8 is platform-specific.

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::{CStr, CString};

// 💀 The meaning of this entire program is undefined,
// 💀 and nothing about its behavior is guaranteed,
// 💀 not even that its behavior resembles the code as written,
// 💀 just because it contains a single instance of undefined behavior!

// 🚨 creates a dangling pointer to a temporary `CString`
// 🚨 that is deallocated at the end of the statement
let ptr = CString::new("Hi!".to_uppercase()).unwrap().as_ptr();

// without undefined behavior, you would expect that `ptr` equals:
dbg!(CStr::from_bytes_with_nul(b"HI!\0").unwrap());

// 🙏 Possibly the program behaved as expected so far,
// 🙏 and this just shows `ptr` is now garbage..., but
// 💀 this violates `CStr::from_ptr`'s safety contract
// 💀 leading to a dereference of a dangling pointer,
// 💀 which is immediate undefined behavior.
// 💀 *BOOM*, you're dead, your entire program has no meaning.
dbg!(unsafe { CStr::from_ptr(ptr) });

This happens because, the pointer returned by as_ptr does not carry any lifetime information, and the CString is deallocated immediately after the expression that it is part of has been evaluated. To fix the problem, bind the CString to a local variable:

use std::ffi::{CStr, CString};

let c_str = CString::new("Hi!".to_uppercase()).unwrap();
let ptr = c_str.as_ptr();

assert_eq!(unsafe { CStr::from_ptr(ptr) }, c"HI!");

pub fn count_bytes(&self) -> usize

Returns the length of self. Like C’s strlen, this does not include the nul terminator.

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

assert_eq!(c"foo".count_bytes(), 3);
assert_eq!(c"".count_bytes(), 0);

pub fn is_empty(&self) -> bool

Returns true if self.to_bytes() has a length of 0.

Examples

assert!(!c"foo".is_empty());
assert!(c"".is_empty());

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

assert_eq!(c"foo".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

assert_eq!(c"foo".to_bytes_with_nul(), b"foo\0");

pub fn bytes(&self) -> Bytes<'_>

🔬This is a nightly-only experimental API. (cstr_bytes)

Iterates over the bytes in this C string.

The returned iterator will not contain the trailing nul terminator that this C string has.

Examples

#![feature(cstr_bytes)]

assert!(c"foo".bytes().eq(*b"foo"));

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

assert_eq!(c"foo".to_str(), Ok("foo"));

pub fn display(&self) -> impl Display

🔬This is a nightly-only experimental API. (cstr_display)

Returns an object that implements Display for safely printing a CStr that may contain non-Unicode data.

Behaves as if self were first lossily converted to a str, with invalid UTF-8 presented as the Unicode replacement character: �.

Examples

#![feature(cstr_display)]

let cstr = c"Hello, world!";
println!("{}", cstr.display());

Trait Implementations

impl<const N: usize, LenT: LenType> AsRef<CStr> for CString<N, LenT>

fn as_ref(&self) -> &CStr

Converts this type into a shared reference of the (usually inferred) input type.

impl<const N: usize, LenT: LenType> Borrow<CStr> for CString<N, LenT>

fn borrow(&self) -> &CStr

Immutably borrows from an owned value.

impl<const N: usize, LenT: Clone + LenType> Clone for CString<N, LenT>

fn clone(&self) -> CString<N, LenT>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize, LenT: LenType> Debug for CString<N, LenT>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: usize, LenT: LenType> Default for CString<N, LenT>

fn default() -> Self

Returns the “default value” for a type.

impl<const N: usize, LenT: LenType> Deref for CString<N, LenT>

type Target = CStr

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<const N: usize, LenT: Hash + LenType> Hash for CString<N, LenT>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: usize, LenT: LenType> Ord for CString<N, LenT>

fn cmp(&self, rhs: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<const N: usize, const M: usize, LenT1: LenType, LenT2: LenType> PartialEq<CString<M, LenT2>> for CString<N, LenT1>

fn eq(&self, rhs: &CString<M, LenT2>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize, const M: usize, LenT1: LenType, LenT2: LenType> PartialOrd<CString<M, LenT2>> for CString<N, LenT1>

fn partial_cmp(&self, rhs: &CString<M, LenT2>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const N: usize, LenT: LenType> Eq for CString<N, LenT>