Static Strings

Are the strings that we have used so far changeable?

This will print: Hello. But in what sense did we change it? We abruptly changed all the content of the string, not just some characters. In fact, so far we changed strings only by assigning to a string variable a string literal or another string variable.

This program will print: 0 10 6.

First, notice that we specified the type of the three variables. That type is &str, which means reference to str.

The str word is defined in the standard library as the type of an unmodifiable array of bytes representing a UTF-8 string. Each time the compiler parses a literal string, it stores in a static program area the characters of that string, and that area is of str type. Then the compiler uses a reference to that area as the value of the literal string expression, so any string literal is of type &str.

In the example, the size_of_val generic function is invoked on the three string variables. Remember that such a function returns the size of the object referenced by its argument. If the argument is a, which is of type &str, this function returns the size of the string buffer referenced by a, which is of type str.

So the sizes of the three buffers referred to by the variables a, b, and c are printed. Such sizes are, respectively, 0, 10, and 6 bytes. Indeed, the first string was empty, so its buffer occupies no bytes; the second string contained exactly ten digits, and each digit is a character that occupies one byte, so that string buffer occupies ten bytes; the third string contained only five characters, but the number six was printed as its length. This is because of the UTF-8 notation. In that notation, every character is represented by one or more bytes, depending on the character. The ASCII characters are represented by a single byte, while the “grave e” character, that is, è, is represented by two bytes. So, the whole string of five characters is represented by six bytes.

Notice that the buffers referred to by the a, b, and c variables are of the same type, which is str, but they have different lengths: 0, 10, and 6. So here, for the first time, we see a type that hasn’t an associated length.

Such types are not very common, and they have some limitations. One is that you cannot declare a variable or a function argument of the type. Another obvious limitation is that you cannot ask the size of the type.

All the three previous statements are illegal, so for each of them the compiler emits the error message: the size for values of type `str` cannot be known at compilation time.

But then, how can the previous program get the sizes of the buffers? In C language, string terminators are used to mark the end of strings, but Rust has no string terminators.

Actually the &str type is not a normal Rust reference, containing just a pointer, rather it is a pair of a pointer and a length. The pointer value is the address of the beginning of the string buffer, and the length value is the number of bytes of the string buffer.

This program in a 64-bit system will print: 16 16 16; 8 8 8, while in a 32-bit system it will print: 8 8 8; 4 4 4.

The first print statement prints the sizes of the variables themselves, which are of type &str . Such variables result in sizes that are twice as large as that of a normal reference, as they contain a pointer object and a usize object.

The second print statement prints the sizes of references to the variables themselves, which are of type &&str. They are normal references.

When we invoke the len function on a static string, we just read the second field of that pair, without even accessing the string buffer, so this function is quite efficient.

Dynamic Strings

So if we want to create or change the contents of a string at runtime, the &str type, which we always used so far, is unfit.

This will print: Hello.

The a variable is of type String, which is the type Rust uses for dynamic strings.

In Rust there are no literal dynamic strings; literal strings are always static. But a dynamic string may be constructed from a static string in several ways. One is to invoke the to_string function on a static string. The name of this function should be thought of as if it were to_dynamic_string or to_String. But the first alternative would be too long, and the second one would violate the convention of never using uppercase letters in the name of functions.

A dynamic string can be printed like any static string, as shown by the last statement of the example. But it is capable of something a static string cannot do: it can grow.

Each of the second, third, and fourth statements add a character at the end of the string.

This prints: Hi.

The a variable is initialized to contain “Xy”. Then the character at position 0 is removed, leaving “y”. Then an “H” is inserted at position 0, obtaining a “Hy”. Then the last character is popped from the end, leaving “H”. Then an “i” is pushed at the end, obtaining the final “Hi”.

Implementation of String

While a Rust static string is somewhat similar to a C language string, without a string terminator but with an additional counter, a Rust dynamic string is quite similar to a C++ std::string object. Both Rust and C++ dynamic string types contain a dynamically allocated array of bytes, which contains the characters of the string.

The main difference between Rust and C++ dynamic string types is that while for C++ strings each byte of the buffer represents exactly one character, the buffer of any Rust dynamic string, like that of any Rust static string, is guaranteed to use the UTF-8 encoding; so a byte of it does not necessarily correspond to a character.

Remaining in the Rust language, there are similarities of strings with arrays, and with vectors. While static string buffers are similar to arrays, that is, the str type is similar to the generic [u8; N] type, dynamic strings are similar to vectors of bytes, that is, the String type is similar to the Vec<u8> type.

Indeed, the functions we saw previously (push, pop, insert, and remove, and also the len function) have the same name of the corresponding functions of the Vector generic type.

This may print: 8 1; 8 2; 8 3. That means that in all these cases the allocated buffer is eight bytes long. And the ASCII character e occupies just one byte in that buffer; the accented character è occupies two bytes; and the currency symbol € occupies three bytes. The number of bytes occupied by the characters is because of the UTF-8 standard, while the size of the buffers is dependent on the implementation of the Rust standard library. It has changed in previous versions of Rust, and it may change in future versions.

The as_ptr function (to be read “as pointer”) returns the address of the heap-allocated buffer containing the characters of the string.

Notice that when the s1 string is empty, the capacity is zero, meaning that there are no allocated bytes. As no buffer is allocated, the address of such buffer is simply 1, which is an invalid memory address.

When one ASCII character is added to s1, an 8-byte buffer is allocated at an address represented by the hexadecimal number 55f7d528f9d0.

Adding seven other characters, no reallocations are required, because the allocated buffer is large enough.

When the ninth character is added, a reallocation is required, but, as the memory immediately following the buffer of s1 is still free, the buffer may simply be extended to 16 bytes. This avoids the overhead of allocating a new buffer, copying the eight used bytes, and deallocating the previous buffer.

This buffer extension may be long, as this program has no other allocations, so all the address space is available. So, just before adding the seventeenth character to the s1 string, the s2 variable is declared and initialized. It allocates a buffer containing only the letter x. That buffer will go just after the current buffer for the s1 string. So, when the buffer for the s1 string must be extended to 32 bytes, it has to be reallocated.

This can be seen by looking at the addresses printed by the program. Remember that 20 in hexadecimal is 32 in decimal. The buffer for s2 begins 32 bytes after the original position where the buffer for s1 begins. After the last push on s1, its buffer has been moved 32 bytes after the position where the buffer for s1 begins.

Creating Dynamic Strings

This will print: ().

The new function of the String type is the basic constructor, similar to a default constructor in C++.

The from function of the String type is the converter constructor, similar to a non-default constructor in C++.

The functions to_string and to_owned are now interchangeable, but there are both because historically they were somewhat different.

The format macro is identical to the print macro, with the only difference that while the latter sends its result to the console, the former returns a String object containing the result.

This will print: (a,a,a,a,).

Instead, the statements in the fifth and sixth lines would generate compilation errors.

For the fifth line, the error message format argument must be a string literal is printed. Indeed, the format macro, like the print and println macros, requires that the first argument is a literal.

For the sixth line, the error message 1 positional argument in format string, but no arguments were given is printed. This is because the first argument of the format macro must contain as many placeholders as the successive arguments to the macro.

Converting Static Strings to Dynamic Strings

We have already seen how to convert a static string to a dynamic string, that is, to get an object of type String whose contents is equal to that of a given object of type &str. Is the reverse conversion possible, from a dynamic string to a static string?

It will print: abc abc abc.

In the first line, a dynamic string is declared and initialized.

In the second line, a reference to it is assigned to a variable whose type is that of reference to String.

In the third line, a reference to the dynamic string is assigned to a variable whose type is that of reference to str, that is, to a static string.

It is allowed to initialize a variable of type String with an expression of type &str, because the standard library defines such types in a way to allow an implicit conversion between them.

Notice that the two kinds of conversion are quite different.

A conversion from a static string to a dynamic string creates a distinct object, which allocates a distinct buffer and copies into it all the characters of the static string.

Whereas a conversion from a dynamic string to a static string creates a reference inside the dynamic string. No characters are copied. They are shared between the two strings.

Concatenating Strings

This will print: Hello Hello Hello Hello.

First, the two static strings ss1 and ss2 are declared. Then, they are converted to the dynamic strings ds1 and ds2. Then, the format macro is used four times to concatenate any combination of such strings: static-static, static-dynamic, dynamic-static, and dynamic-dynamic. The result is the same in all four cases.

It will print: Hello, world!.

In each iteration, the previous result is concatenated with the new string piece, and the result becomes the new partial result.

Though, this is inefficient, because any iteration definitely destroys and reallocates the result string.

The function push_str takes a static string and pushes all its characters to the end of the receiving string. It may be more efficient because, if the appended characters can be contained in the already allocated buffer, no reallocation is required.

It is a kind of syntactic sugar.

This program is equivalent to the previous ones.

Notice, at the fifth and sixth lines, that a dynamic string is passed as an argument of push_str and +=, respectively. However, such functions expect a static string, so our dynamic strings have to be converted to static strings beforehand. Such effect is obtained using the & operator.

At last, a single character is appended to the result string using push.