Struct HeapCStr 

pub struct HeapCStr<const N: usize> { /* private fields */ }

Available on crate features alloc and types-cstr and types only.

堆上定容安全 C 字符串，语义与 StackCStr 一致，适用于较长的敏感文本。

N 包含结尾 \0，N >= 1。

Feature Requirement

需要启用 "types-cstr" 与 "alloc" 特性。

Examples

use core::convert::TryInto;
use lib_unknown::types::cstr::HeapCStr;

let s: HeapCStr<16> = "hi".try_into().unwrap();
assert_eq!(&*s, c"hi");

Implementations

impl<const N: usize> HeapCStr<N>

pub const CAPACITY: usize = N

容器总容量（含结尾 \0）。

Feature Requirement

需要启用 "types-cstr" 与 "alloc" 特性。

pub fn new() -> Self

创建空 C 字符串（仅含结尾 \0）。

Feature Requirement

需要启用 "types-cstr" 与 "alloc" 特性。

Panics

• 当 N == 0 时 panic：连结尾 \0 都放不下。

impl<const N: usize> HeapCStr<N>

pub unsafe fn from_raw_parts_mut( ptr: *mut u8, len: usize, ) -> Result<Self, CStrError>

从原始可变指针拷贝并擦除源缓冲构造安全 C 字符串。

在 len 范围内找首个 \0 截断为载荷；找不到则报 CStrError::MissingNul。无论成败都清零源 len 字节。

Safety

调用此函数必须保证：

1. ptr 非空且在 len 范围内可读写、正确对齐；
2. 调用期间该内存不被其他线程并发访问。

Errors

• ptr 为空时返回 CStrError::NullPointer。
• len 内无 \0 时返回 CStrError::MissingNul。
• 载荷（含结尾 \0）超出 N 时返回 CStrError::CapacityExceeded。

pub fn try_grow<const M: usize>(self) -> Result<HeapCStr<M>, CStrError>

将内容搬运到容量为 M 的同类 C 字符串中。

本方法按值取走 self，原容器在返回前（无论成败）被清零。

Feature Requirement

需要启用 "types-cstr" 特性（HeapCStr 相关还需 "alloc" 特性）。

Examples

use core::convert::TryInto;
use lib_unknown::types::cstr::StackCStr;

let s: StackCStr<4> = "hi".try_into().unwrap();
let c = s.try_grow::<8>().unwrap();
assert_eq!(&*c, c"hi");

Errors

• 当已有长度（含 \0）超出 M 时返回 CStrError::CapacityExceeded。

Panics

• 内部 expect("Capacity already checked")：前置长度检查保证不触发，仅防御性保留。

pub fn push_bytes_into<const M: usize>( self, suffix: &[u8], ) -> Result<HeapCStr<M>, CStrError>

将自身与 suffix 拼接为容量 M 的新 C 字符串。

suffix 为不含 \0 的载荷字节（允许非 UTF-8）；含 \0 时报 CStrError::InteriorNul，其下标为拼接后载荷中的绝对下标。 本方法按值取走 self，原容器在返回前（无论成败）被清零。

Feature Requirement

需要启用 "types-cstr" 特性（HeapCStr 相关还需 "alloc" 特性）。

Examples

use core::convert::TryInto;
use lib_unknown::types::cstr::StackCStr;

let s: StackCStr<4> = "hi".try_into().unwrap();
let c = s.push_bytes_into::<8>(b"!").unwrap();
assert_eq!(&*c, c"hi!");

Errors

• 当拼接后长度（含 \0）超出 M 时返回 CStrError::CapacityExceeded。
• 当 suffix 含 \0 时返回 CStrError::InteriorNul。

Panics

• 两处内部 expect("Capacity already checked")：前置长度检查保证不触发，仅防御性保留。

pub fn concat_into<const M: usize>( self, rhs: impl AsRef<[u8]>, ) -> Result<HeapCStr<M>, CStrError>

将自身与 rhs 拼接为容量 M 的新 C 字符串（rhs 为任意可借用为字节切片的类型）。

本方法按值取走 self，原容器在返回前（无论成败）被清零。

Feature Requirement

需要启用 "types-cstr" 特性（HeapCStr 相关还需 "alloc" 特性）。

Examples

use core::convert::TryInto;
use lib_unknown::types::cstr::StackCStr;

let s: StackCStr<4> = "hi".try_into().unwrap();
let c = s.concat_into::<8>(b"!").unwrap();
assert_eq!(&*c, c"hi!");

Errors

• 当拼接后长度（含 \0）超出 M 时返回 CStrError::CapacityExceeded。
• 当 rhs 含 \0 时返回 CStrError::InteriorNul，其下标为拼接后载荷中的绝对下标。

Panics

• 内部 expect("Capacity already checked")：前置长度检查保证不触发，仅防御性保留。

Methods from Deref<Target = StdCStr>

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

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

pub fn as_c_str(&self) -> &CStr

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

Returns the same string as a string slice &CStr.

This method is redundant when used directly on &CStr, but it helps dereferencing other string-like types to string slices, for example references to Box<CStr> or Arc<CStr>.

pub fn to_string_lossy(&self) -> Cow<'_, str>

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.

Examples

Calling to_string_lossy on a CStr containing valid UTF-8. The leading c on the string literal denotes a CStr.

use std::borrow::Cow;

assert_eq!(c"Hello World".to_string_lossy(), Cow::Borrowed("Hello World"));

Calling to_string_lossy on a CStr containing invalid UTF-8:

use std::borrow::Cow;

assert_eq!(
    c"Hello \xF0\x90\x80World".to_string_lossy(),
    Cow::Owned(String::from("Hello �World")) as Cow<'_, str>
);

Trait Implementations

impl<const N: usize> AsRef<CStr> for HeapCStr<N>

fn as_ref(&self) -> &StdCStr

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

impl<const N: usize> AsRef<[u8]> for HeapCStr<N>

fn as_ref(&self) -> &[u8]

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

impl<const N: usize> Borrow<CStr> for HeapCStr<N>

fn borrow(&self) -> &StdCStr

Immutably borrows from an owned value.

impl<const N: usize> CStr for HeapCStr<N>

fn as_cstr(&self) -> &StdCStr

Available on crate feature types-cstr only.

以 &core::ffi::CStr 形式查看内容，可直接传给 sys_open 等。

fn dyn_clone(&self) -> Box<dyn CStr>

Available on crate features alloc and types-cstr only.

类型擦除的堆克隆，用于 Box<dyn CStr> 容器。

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

Available on crate feature types-cstr only.

以字节切片查看载荷（不含结尾 \0），允许非 UTF-8。

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

Available on crate feature types-cstr only.

以字节切片查看含结尾 \0 的完整存储。

fn as_ptr(&self) -> *const c_char

Available on crate feature types-cstr only.

返回载荷的原始指针，指向容器内部存储（等价于 as_cstr().as_ptr()）。

fn len(&self) -> usize

Available on crate feature types-cstr only.

返回载荷的字节长度（不含结尾 \0）。

fn is_empty(&self) -> bool

Available on crate feature types-cstr only.

载荷是否为空。

impl<const N: usize> Clone for HeapCStr<N>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for HeapCStr<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for HeapCStr<N>

fn default() -> Self

Returns the “default value” for a type.

impl<const N: usize> Deref for HeapCStr<N>

type Target = CStr

The resulting type after dereferencing.

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

Dereferences the value.

impl<const N: usize> Display for HeapCStr<N>

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

Formats the value using the given formatter.

impl<const N: usize> Drop for HeapCStr<N>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<const N: usize> Eq for HeapCStr<N>

impl<const N: usize> FromStr for HeapCStr<N>

type Err = CStrError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<const N: usize> Hash for HeapCStr<N>

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> Ord for HeapCStr<N>

fn cmp(&self, other: &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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl<'a, const N: usize> PartialEq<&'a CStr> for HeapCStr<N>

fn eq(&self, other: &&'a StdCStr) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a, const N: usize> PartialEq<&'a str> for HeapCStr<N>

fn eq(&self, other: &&'a str) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const N: usize> PartialEq<CStr> for HeapCStr<N>

fn eq(&self, other: &StdCStr) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const N: usize, const M: usize> PartialEq<HeapCStr<M>> for HeapCStr<N>

fn eq(&self, other: &HeapCStr<M>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const N: usize, const M: usize> PartialEq<HeapCStr<N>> for StackCStr<M>

fn eq(&self, other: &HeapCStr<N>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const N: usize, const M: usize> PartialEq<StackCStr<M>> for HeapCStr<N>

fn eq(&self, other: &StackCStr<M>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const N: usize> PartialEq<String> for HeapCStr<N>

fn eq(&self, other: &String) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const N: usize> PartialEq<str> for HeapCStr<N>

fn eq(&self, other: &str) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const N: usize> PartialOrd for HeapCStr<N>

fn partial_cmp(&self, other: &Self) -> 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> TryFrom<&CStr> for HeapCStr<N>

type Error = CStrError

The type returned in the event of a conversion error.

fn try_from(s: &StdCStr) -> Result<Self, Self::Error>

Performs the conversion.

impl<const N: usize> TryFrom<&[u8]> for HeapCStr<N>

type Error = CStrError

The type returned in the event of a conversion error.

fn try_from(s: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl<const N: usize> TryFrom<&mut [u8; N]> for HeapCStr<N>

type Error = CStrError

The type returned in the event of a conversion error.

fn try_from(arr: &mut [u8; N]) -> Result<Self, Self::Error>

Performs the conversion.

impl<const N: usize> TryFrom<&mut [u8]> for HeapCStr<N>

type Error = CStrError

The type returned in the event of a conversion error.

fn try_from(arr: &mut [u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl<const N: usize> TryFrom<&str> for HeapCStr<N>

type Error = CStrError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl<const N: usize> TryFrom<Box<[u8; N]>> for HeapCStr<N>

type Error = CStrError

The type returned in the event of a conversion error.

fn try_from(b: Box<[u8; N]>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const N: usize> TryFrom<String> for HeapCStr<N>

type Error = CStrError

The type returned in the event of a conversion error.

fn try_from(s: String) -> Result<Self, Self::Error>

Performs the conversion.

impl<const N: usize> TryFrom<Vec<u8>> for HeapCStr<N>

type Error = CStrError

The type returned in the event of a conversion error.

fn try_from(v: Vec<u8>) -> Result<Self, Self::Error>

Performs the conversion.