Rust for C-Programmers

5.4 Data Types

Rust is statically typed, meaning every variable’s type is known at compile time, and it is strongly typed, preventing automatic conversions to unrelated types (such as implicitly converting an integer to a floating-point). This strong static typing catches errors early and avoids subtle bugs caused by unintended type mismatches.

5.4.1 Scalar Types

Rust’s scalar types represent single, discrete values: integers, floating-point numbers, booleans, and characters.

Integers

Rust provides various integer types, distinguished by their size and by whether they are signed or unsigned:

• Fixed-size: i8, i16, i32, i64, i128 (signed) and u8, u16, u32, u64, u128 (unsigned).
• Pointer-sized: isize (signed) and usize (unsigned). These match the pointer width of the target platform (32 or 64 bits, most commonly).

By default, unsuffixed integer literals in Rust are 32-bit signed integers (i32).

isize and usize

These types mirror the system’s pointer width. On many 32-bit architectures, they are 32 bits wide; on most 64-bit architectures, they are 64 bits wide. They are often used for indexing collections: array indices in Rust must be usize. If you have an integer in another type (like i32), you need to cast it to usize when using it as an index.

Floating-Point Numbers

Rust supports two floating-point types, both following the IEEE 754 standard:

• f32 (32-bit)
• f64 (64-bit, and the default)

Modern CPUs often handle double-precision (f64) operations as efficiently as—or more efficiently than—single-precision, so f64 is a common default choice.

Booleans and Characters

• bool: Can be either true or false. Rust typically stores booleans in a byte for alignment reasons.
• char: A four-byte Unicode scalar value. This differs from C’s char, which is usually one byte and might represent ASCII or another encoding.

5.4.2 Primitive Compound Types: Tuple and Array

Rust provides tuple and array as primitive compound types, each useful in different scenarios. They both bundle multiple values but differ in storage details and type restrictions.

5.4.3 Tuple

A tuple is a fixed-size collection of elements, each of which can have a distinct type. This differs from C, which lacks a built-in anonymous tuple type (though you can use structs).

Tuple Type and Value Syntax

• Type: (T1, T2, T3, ...)
• Value: (v1, v2, v3, ...)

#![allow(unused)]
fn main() {
let tup: (i32, f64, char) = (500, 6.4, 'x');
}

Tuples have a size known at compile time and cannot change length.

Singleton Tuples and the Unit Type

• Singleton tuple (x,): Note the trailing comma to distinguish it from (x).
• Unit type (): A zero-length tuple, often used to indicate “no meaningful value.” Functions that return “nothing” actually return ().

#![allow(unused)]
fn main() {
let single = (5,);  // a single-element tuple
let unit: () = (); // the unit type
}

Accessing Tuple Elements

Because each element in a tuple can have a different type, Rust uses a field-like syntax for indexing, rather than tup[i]:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

• They must be numeric literals—you cannot replace the index with a constant or variable (e.g., tup.Z is invalid).
• Because each field may hold a different type, there’s no concept of runtime tuple indexing; the compiler must know which field you refer to at compile time.

If you need random or runtime-based indexing, use an array, slice, or vector instead.

Mutability and Initialization

A tuple is immutable by default. Declaring it as mut allows you to modify its fields. You must still initialize all fields at once:

#![allow(unused)]
fn main() {
let mut tup = (500, 6.4, 'x');
tup.0 = 600; // Valid, since 'tup' is mutable
}

Partial initialization of a tuple (leaving some fields uninitialized) is not allowed.

Destructuring

You can destructure a tuple into individual variables:

#![allow(unused)]
fn main() {
let tup = (1, 2, 3);
let (a, b, c) = tup;
println!("a = {}, b = {}, c = {}", a, b, c);
}

We will explore variable bindings and destructuring further in the next sections.

Tuples vs. Structs

In C, you might define a struct to group multiple data fields. Rust also supports structs with named fields. Consider a tuple if:

• You have a small set of elements (possibly of varied types).
• You do not need named fields.
• The positional meaning is straightforward.

Use a struct if:

• You need more complex data organization.
• Named fields improve clarity.
• You want additional methods or traits on your data type.

5.4.4 Array

An array in Rust is a fixed-size sequence of elements of the same type. Rust arrays are bounds-checked to prevent out-of-bounds access.

Declaration and Initialization

[Type; Length] denotes an array of Type with a fixed Length:

#![allow(unused)]
fn main() {
let array: [i32; 3] = [1, 2, 3];
}

Rust requires the array length to be known at compile time, but the array’s contents can be initialized using expressions that evaluate at runtime.

let x = 5;
let y = x * 2;
// The array length is known at compile time (3),
// but its contents are computed using runtime variables.
let array: [i32; 3] = [x, y, x + y]; // [5, 10, 15]

You can fill all elements with the same value:

#![allow(unused)]
fn main() {
let zeros = [0; 5]; // [0, 0, 0, 0, 0]
}

Type Inference

Rust often infers the array’s type and length from the initializer:

#![allow(unused)]
fn main() {
let array = [1, 2, 3]; // Inferred as [i32; 3]
}

You may also use a suffix if needed:

#![allow(unused)]
fn main() {
let array = [1u8, 2, 3]; // Inferred as [u8; 3]
}

Accessing Array Elements

Arrays use zero-based indexing. Indices must be usize:

#![allow(unused)]
fn main() {
let array: [i32; 3] = [1, 2, 3];
let index = 1;
let second = array[index];
println!("Second element is {}", second);
}

If you go out of bounds, Rust will panic (a runtime error) rather than allow arbitrary memory access.

Multidimensional Arrays

You can nest arrays to form multidimensional arrays:

#![allow(unused)]
fn main() {
let matrix: [[i32; 3]; 2] = [
    [1, 2, 3],
    [4, 5, 6],
];
}

This is effectively an array of arrays.

Memory Layout and the Copy Trait

• Arrays are stored contiguously, with no padding between elements.
• If a type T implements the Copy trait (e.g., primitive numeric types), [T; N] also implements Copy. The entire array can then be copied without affecting the original data.

When to Use Arrays

Use arrays when the size is fixed at compile time and you want efficient, stack-allocated, bounds-checked storage. For resizable collections, Rust provides the Vec<T> type (vectors), which we will explore in a later chapter.

5.4.5 Stack vs. Heap Allocation

Rust’s primitive data types (scalars, tuples, arrays) typically reside on the stack when declared as local variables, because their size is known at compile time. This makes their allocation and deallocation straightforward. In contrast, types like Vec<T> or String store their elements on the heap, allowing dynamic resizing.

However, any type—primitive or otherwise—can reside on the heap if it is a field within a heap-allocated structure. For instance, the buffer of a Vec<T> always lives on the heap, regardless of the type of T. We will cover these details in future chapters on ownership and collections.