CodeBlanks Logo Icon CodeBlanks
Login Register

Integers

Learn signed and unsigned integer types like i32 and u64.

Integers

Rust splits integers into signed (i8, i16, i32, i64, i128) and unsigned (u8 … u128); the number is the bit width. isize/usize match the CPU width and are used for indexes. The default is i32.

let a: u8 = 255;          // 0..=255
let b: i8 = -128;         // -128..=127
let buyuk = 1_000_000;    // _ is for readability
let hex = 0xff;           // 255

u8 is ideal for a byte; IDs and counters usually use u32/u64.

Overflow and explicit behavior

Overflow at run time panics in debug builds. Methods are used to choose the behavior explicitly:

let x: u8 = 250;
println!("{:?}", x.checked_add(10));   // None
println!("{}", x.wrapping_add(10));     // 4
println!("{}", x.saturating_add(10));   // 255

In money and counter calculations, the checked_* methods let you catch overflow as an error.

Practice Overflow methods

For let x: u8 = 250;, print x.checked_add(10), x.wrapping_add(10) and x.saturating_add(10) with println!("{:?} {} {}", ...).

Starter code

main.rs
fn main() {
    // buraya yaz
}

Sample solution

main.rs
fn main() {
    let x: u8 = 250;
    println!("{:?} {} {}", x.checked_add(10), x.wrapping_add(10), x.saturating_add(10));
}

Expected output

None 4 255

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 What happens with <code>let x: u8 = 256;</code>?

  • A run-time panic
  • Compile error: value out of range Correct answer
  • x becomes 0
  • x becomes 255

Explanation: u8 holds at most 255; the compiler rejects an overflowing literal at compile time.

2 Saturating add

Question 
let x: u8 = 250;
let y = x.____(10);  // 255
Answer 
let x: u8 = 250;
let y = x.saturating_add(10);  // 255

Explanation: saturating_add stops at the type's maximum value on overflow.

3 Type and range

Term Meaning
u8 0..=255
i8 -128..=127
usize Index type
i32 Default integer

All lessons in Beginner

1 Rust basics

  1. What is Rust?
  2. Project with Cargo
  3. Your first program
  4. println! and formatting
  5. Comments
  6. Summary - Rust basics

2 Variables

  1. Variables with let
  2. Mutability with mut
  3. Constants with const
  4. Static variables
  5. Shadowing
  6. Summary - Variables

3 Data types

  1. Integers
  2. Floating point
  3. Bool and char
  4. Tuple
  5. Array
  6. Summary - Data types

4 Strings

  1. &str vs String
  2. Creating a String
  3. Concatenating strings
  4. format! macro
  5. String length
  6. Summary - Strings

5 Project: Calculator

  1. Project skeleton
  2. Reading input
  3. Computing
  4. Error handling
  5. Loop and exit

6 Functions

  1. Defining with fn
  2. Parameters
  3. Return value
  4. Expressions and statements
  5. Early return
  6. Summary - Functions

7 Control flow

  1. if-else
  2. match basics
  3. loop
  4. while loop
  5. for loop
  6. Summary - Control flow

8 Ownership

  1. What is ownership?
  2. Move semantics
  3. Copy trait
  4. Functions and ownership
  5. Return and ownership
  6. Summary - Ownership

9 Borrowing

  1. References
  2. Mutable reference
  3. Borrowing rules
  4. Dangling reference
  5. References and functions
  6. Summary - Borrowing

10 Slices

  1. String slices
  2. Slice syntax
  3. Array slices
  4. Slices and functions
  5. Range types
  6. Summary - Slices

11 Project: Guessing game

  1. Game skeleton
  2. Reading input
  3. Comparing numbers
  4. Random number
  5. Loop and exit

12 Structs

  1. Struct definition
  2. Creating an instance
  3. Tuple struct
  4. Unit-like struct
  5. Field update
  6. Summary - Structs

13 Methods

  1. impl block
  2. self parameter
  3. &mut self
  4. Associated functions
  5. Multiple impl blocks
  6. Summary - Methods

14 Enums

  1. Enum definition
  2. Variants
  3. Variants with data
  4. Option<T>
  5. Option instead of null
  6. Summary - Enums

15 Pattern matching

  1. match patterns
  2. Value binding
  3. if let
  4. while let
  5. _ wildcard
  6. Summary - Pattern matching

16 Project: To-do CLI

  1. Task model
  2. Adding
  3. Listing
  4. Marking done
  5. Reading commands

17 Vectors

  1. Vec<T>
  2. Push and pop
  3. Index and get
  4. Looping a vector
  5. with_capacity
  6. Summary - Vectors

18 Advanced strings

  1. String and &str conversion
  2. chars and bytes
  3. Slicing strings
  4. contains and replace
  5. split and join
  6. Summary - Advanced strings

19 Error handling

  1. Result<T, E>
  2. panic!
  3. ? operator
  4. match and Result
  5. unwrap and expect
  6. Summary - Error handling

20 Beginner final

  1. Vowel counter
  2. Average calculator
  3. Bank account
  4. Temperature converter