Utilities related to FFI bindings.
This module provides utilities to handle data across non-Rust interfaces, like other programming languages and the underlying operating system. It is mainly of use for FFI (Foreign Function Interface) bindings and code that needs to exchange C-like strings with other languages.
Rust represents owned strings with the
String type, and
borrowed slices of strings with the
str primitive. Both are
always in UTF-8 encoding, and may contain nul bytes in the middle,
i.e., if you look at the bytes that make up the string, there may
\0 among them. Both
str store their length
explicitly; there are no nul terminators at the end of strings
like in C.
C strings are different from Rust strings:
Encodings - Rust strings are UTF-8, but C strings may use other encodings. If you are using a string from C, you should check its encoding explicitly, rather than just assuming that it is UTF-8 like you can do in Rust.
Character size - C strings may use
wchar_t-sized characters; please note that C’s
charis different from Rust’s. The C standard leaves the actual sizes of those types open to interpretation, but defines different APIs for strings made up of each character type. Rust strings are always UTF-8, so different Unicode characters will be encoded in a variable number of bytes each. The Rust type
charrepresents a ‘[Unicode scalar value]’, which is similar to, but not the same as, a ‘[Unicode code point]’.
Nul terminators and implicit string lengths - Often, C strings are nul-terminated, i.e., they have a
\0character at the end. The length of a string buffer is not stored, but has to be calculated; to compute the length of a string, C code must manually call a function like
char-based strings, or
wchar_t-based ones. Those functions return the number of characters in the string excluding the nul terminator, so the buffer length is really
len+1characters. Rust strings don’t have a nul terminator; their length is always stored and does not need to be calculated. While in Rust accessing a string’s length is an O(1) operation (because the length is stored); in C it is an O(n) operation because the length needs to be computed by scanning the string for the nul terminator.
Internal nul characters - When C strings have a nul terminator character, this usually means that they cannot have nul characters in the middle — a nul character would essentially truncate the string. Rust strings can have nul characters in the middle, because nul does not have to mark the end of the string in Rust.
Representations of non-Rust strings
CStr are useful when you need to transfer
UTF-8 strings to and from languages with a C ABI, like Python.
From Rust to C:
CStringrepresents an owned, C-friendly string: it is nul-terminated, and has no internal nul characters. Rust code can create a
CStringout of a normal string (provided that the string doesn’t have nul characters in the middle), and then use a variety of methods to obtain a raw
*mut u8that can then be passed as an argument to functions which use the C conventions for strings.
From C to Rust:
CStrrepresents a borrowed C string; it is what you would use to wrap a raw
*const u8that you got from a C function. A
CStris guaranteed to be a nul-terminated array of bytes. Once you have a
CStr, you can convert it to a Rust
&strif it’s valid UTF-8, or lossily convert it by adding replacement characters.
- A type representing an owned, C-compatible, nul-terminated string with no nul bytes in the middle.
- An error indicating that a nul byte was not in the expected position.
- An error indicating that an interior nul byte was found.