Rust変数の全体像 ── let・mut・const・staticの使い分けとシャドーイングまで

fn main() {
    let x = 42;
    println!("{}", x); // 42
}

fn main() {
    // parse()の戻り値型が曖昧 → 型注釈が必要
    let guess: u32 = "42".parse().expect("数値ではありません");
    println!("{}", guess);
}

fn main() {
    let user_name = "田中"; // OK: スネークケース
    let userName = "田中";  // 警告: should have a snake case name
    println!("{} {}", user_name, userName);
}

fn main() {
    let _unused = 100; // 未使用でも警告なし
}

fn main() {
    let x = 5;
    x = 10; // コンパイルエラー: cannot assign twice to immutable variable
}

fn main() {
    let mut counter = 0;
    counter += 1;
    counter += 1;
    println!("counter = {}", counter); // counter = 2
}

fn main() {
    let x = 5;
    let x = x + 1;   // 元のxをシャドーイング → 6
    let x = x * 2;   // さらにシャドーイング → 12
    println!("{}", x); // 12
}

fn main() {
    // シャドーイング: 型を変更できる
    let data = "hello";
    let data = data.len(); // &str → usize に型が変わる
    println!("{}", data);  // 5

    // mut: 型は変更できない
    let mut value = "hello";
    // value = value.len(); // コンパイルエラー: 型が合わない
}

fn main() {
    let x = 10;
    {
        let x = x + 5; // 内側のスコープでシャドーイング
        println!("内側: {}", x); // 15
    }
    println!("外側: {}", x); // 10（元のxが有効）
}

const MAX_CONNECTIONS: u32 = 100;
const PI: f64 = 3.141592653589793;

fn main() {
    println!("最大接続数: {}", MAX_CONNECTIONS);
    println!("円周率: {}", PI);
}

static LANGUAGE: &str = "Rust";

fn main() {
    println!("{}", LANGUAGE); // Rust
}

static mut COUNTER: u32 = 0;

fn increment() {
    unsafe {
        COUNTER += 1;
    }
}

fn main() {
    increment();
    increment();
    unsafe {
        println!("COUNTER = {}", COUNTER); // COUNTER = 2
    }
}

use std::sync::Mutex;

static COUNTER: Mutex<u32> = Mutex::new(0);

fn main() {
    *COUNTER.lock().unwrap() += 1;
    *COUNTER.lock().unwrap() += 1;
    println!("COUNTER = {}", COUNTER.lock().unwrap()); // COUNTER = 2
}

use std::sync::atomic::{AtomicU32, Ordering};

static COUNTER: AtomicU32 = AtomicU32::new(0);

fn main() {
    COUNTER.fetch_add(1, Ordering::SeqCst);
    COUNTER.fetch_add(1, Ordering::SeqCst);
    println!("COUNTER = {}", COUNTER.load(Ordering::SeqCst)); // COUNTER = 2
}

fn main() {
    let a = 42;       // i32（デフォルト）
    let b = 3.14;     // f64（デフォルト）
    let c = true;     // bool
    let d = 'あ';     // char（Unicodeに対応）
    let e: u8 = 255;  // 明示的に型指定
    println!("{} {} {} {} {}", a, b, c, d, e);
}

fn main() {
    // タプル: 異なる型をまとめる
    let point: (f64, f64) = (1.5, 3.2);
    let (x, y) = point; // 分配束縛で取り出す
    println!("x={}, y={}", x, y);

    // 配列: 同じ型・固定長
    let months = ["1月", "2月", "3月"];
    println!("最初の月: {}", months[0]);

    // 配列の型注釈: [要素型; 要素数]
    let zeros: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0]
    println!("{:?}", zeros);
}

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // 所有権がs1からs2にムーブ
    // println!("{}", s1); // コンパイルエラー: s1はもう使えない
    println!("{}", s2);    // OK
}

fn main() {
    let a = 5;
    let b = a;     // i32はCopyなのでコピーされる
    println!("a={}, b={}", a, b); // 両方使える

    let s1 = String::from("hello");
    let s2 = s1;   // Stringはムーブされる
    // println!("{}", s1); // エラー: 所有権はs2に移動済み
    println!("{}", s2);
}

fn print_length(s: &String) {
    println!("長さ: {}", s.len());
}

fn main() {
    let message = String::from("Rustの変数");
    print_length(&message);   // 借用（所有権は移動しない）
    println!("{}", message);   // まだ使える
}

fn add_exclamation(s: &mut String) {
    s.push('!');
}

fn main() {
    let mut greeting = String::from("Hello");
    add_exclamation(&mut greeting);
    println!("{}", greeting); // Hello!
}

error[E0384]: cannot assign twice to immutable variable `x`

error[E0308]: mismatched types
  expected `i32`, found `&str`

error[E0382]: borrow of moved value: `s`