🚀 BAŞTAN SONA RUST DİLİ BÖLÜM-2: Değişkenler, Mutability ve Veri Tipleri 🦀

Konu Özeti

Rust programlama dilinde değişkenler varsayılan olarak değiştirilemez (immutable) tanımlanır ve değiştirilebilirlik için `mut` anahtar kelimesi kullanılır. Değişken gölgeleme (shadowing) ile aynı isimde yeni değişken tanımlanabilir, bu sayede tür dönüşümü de yapılabilir. Temel veri tipleri skaler (tam sayı, kayan noktalı, boolean, karakter) ve bileşik (tuple, dizi) olarak ikiye ayrılır; dizilerde sınır aşımı çalışma zamanında panic ile sonuçlanır.

🚀 BAŞTAN SONA RUST DİLİ BÖLÜM-2: Değişkenler, Mutability ve Veri Tipleri 🦀

Selamlar! Serimizin 2. bölümüne hoş geldiniz.

İlk bölümde ortam kurulumunu yapıp Cargo ile tanışmıştık. Bu bölümde ise Rust’ın en temel ama diğer dillerden oldukça farklı olan yapısını inceleyeceğiz: Değişkenler, Değiştirilebilirlik (Mutability) ve Veri Tipleri.

---

📌 1. Değişkenler ve Immutable (Değiştirilemez) Yapı 🔒

Rust'ı diğer bir çok dilden ayıran ilk büyük fark şudur: Rust'ta değişkenler varsayılan (default) olarak değiştirilemezdir (immutable).

Bir değişken tanımlamak için `let` anahtar kelimesi kullanılır.

fn main() {
let x = 5;
println!("x'in değeri: {}", x);

// x = 6; // <-- BU SATIR HATA VERİR!
}

Eğer yukarıdaki kodda `x = 6;` yorumunu kaldırıp derlemeye çalışırsanız, Rust derleyicisi size şu hatayı dönecektir:
`cannot assign twice to immutable variable x`

Neden Varsayılan Olarak Immutable?
• Güvenlik: Yanlışlıkla bir değişkenin değerinin değiştirilmesini engeller.
• Paralel Programlama: Thread'ler arası veri paylaşımında race condition (yarış durumu) riskini ortadan kaldırır.

---

🔄 2. Değiştirilebilirlik: `mut` Anahtar Kelimesi 🛠️

Bir değişkenin değerini daha sonra değiştirmemiz gerekiyorsa, bunu açıkça belirtmemiz gerekir. Bunun için `mut` (mutable) kelimesini ekleriz:

fn main() {
let mut y = 10;
println!("y'nin ilk değeri: {}", y);

y = 15; // Artık sorunsuz çalışır!
println!("y'nin yeni değeri: {}", y);
}

---

📌 3. Sabitler (Constants) 🛑

Sabitler de değerleri değiştirilemeyen yapılardır ancak `let` ile tanımlanan immutable değişkenlerden farklıdırlar:

1. `mut` kelimesiyle birlikte kullanılamazlar.
2. `const` anahtar kelimesi ile tanımlanırlar.
3. Veri tipini belirtmek ZORUNDASINIZDIR.
4. Yalnızca derleme zamanında hesaplanabilir ifadeler alabilirler (fonksiyon çağrısı sonucu atanamaz).

const UC_YUZ_ELLI: u32 = 350;
const SAAT_SANIYE: u32 = 60 * 60;

---

👥 4. Gölgeleme (Shadowing) 👤

Rust, aynı isimle tekrar değişken tanımlamamıza izin verir. Buna Shadowing denir. İlk değişken, ikincisi tarafından "gölgelenir".

fn main() {
let x = 5;
let x = x + 1; // x artık 6 oldu

{
let x = x * 2; // Bu blok içinde x = 12
println!("İç bloktaki x: {}", x);
}

println!("Dış bloktaki x: {}", x); // x halen 6
}

Shadowing ile `mut` Arasındaki Fark:
Shadowing yaparken `let` kelimesini tekrar kullandığımız için değişkenin veri tipini değiştirebiliriz:

let spaces = " "; // &str tipi (metin)
let spaces = spaces.len(); // usize tipi (sayı) -> Geçerli!

// mut ile bunu yapamazsınız:
// let mut spaces = " ";
// spaces = spaces.len(); // HATA! Tip değişemez.

---

📊 5. Veri Tipleri (Data Types) 🧬

Rust, statically typed (statik tipli) bir dildir. Derleyici, her değişkenin tipini derleme zamanında bilmelidir. Çoğu zaman tip çıkarımı (type inference) yapabilir.

Veri tipleri iki ana kategoriye ayrılır: Scalar (Tekil) ve Compound (Bileşik).

A. Scalar (Tekil) Tipler
Tek bir değeri temsil ederler.

1. Tam Sayılar (Integers)
İşaretli (signed - `i`) ve İşaretsiz (unsigned - `u`) olmak üzere ikiye ayrılır.

- 8-bit : i8 / u8
- 16-bit : i16 / u16
- 32-bit : i32 / u32 (Default)
- 64-bit : i64 / u64
- 128-bit: i128 / u128
- Mimari : isize / usize

> `isize` ve `usize`, programın çalıştığı bilgisayar mimarisine göre 32-bit veya 64-bit olur (Örn: bellekte indeksleme yaparken `usize` kullanılır).

2. Ondalıklı Sayılar (Floating-Point)
`f32` ve `f64` tipleri vardır. Varsayılan tip `f64`’tür.

let x = 2.0; // f64
let y: f32 = 3.0; // f32

3. Mantıksal Tip (Boolean)
`true` veya `false` değerini alır. 1 byte büyüklüğündedir.

let t = true;
let f: bool = false;

4. Karakter Tipi (Char)
4 byte büyüklüğündedir ve Unicode karakterleri temsil eder (Tek tırnak `'` ile yazılır).

let c = 'z';
let z: char = 'ℤ';
let heart_eyed_cat = '😻'; // Unicode destekler!

---

B. Compound (Bileşik) Tipler
Birden fazla değeri tek bir tip altında toplar.

1. Tuple (Demet)
Farklı tiplerdeki birden fazla değeri bir arada tutar. Sabit uzunluktadır.

fn main() {
let tup: (i32, f64, u8) = (500, 6.4, 1);

// Destructuring (Elemanlara ayırma)
let (x, y, z) = tup;
println!("y değeri: {}", y);

// Indeks ile erişim
let beş_yüz = tup.0;
let altı_nokta_dört = tup.1;
}

2. Array (Dizi)
Aynı tipteki birden fazla değeri bir arada tutar. Uzunluğu sabittir. (Dinamik uzunluk için ileride `Vector` konusunu göreceğiz).

fn main() {
let a = [1, 2, 3, 4, 5];
let b: [i32; 5] = [1, 2, 3, 4, 5]; // Tip ve eleman sayısı belirtme

let c = [3; 5]; // [3, 3, 3, 3, 3] oluşturur.

// Elemana erişim
let birinci = a[0];
}

> Güvenlik Notu: Eğer Rust'ta bir dizinin sınırları dışındaki bir indekse erişmeye çalışırsanız (örn: 5 elemanlı dizide `a[10]`), program derlenir ama çalışma zamanında panic verir (runtime panic). Bellek ihlaline izin verilmez!

---

📝 Bölüm Özeti ve Gelecek Bölüm 🔮

Bu bölümde Rust'ın bellek güvenliği felsefesinin temellerini oluşturan mutability mantığını, değişken gölgeleme (shadowing) mekanizmasını ve temel veri tiplerini inceledik.

👉 Bölüm 3'te Bizi Ne Bekliyor?
• Fonksiyonlar (Functions) ve Parametreler
• Expressions (İfadeler) vs Statements (D
eyimler)
• Akış Kontrolleri (`if / else`, `loop`, `while`, `for`)

Sorularınızı konu altından iletebilirsiniz. Bir sonraki bölümde görüşmek üzere! 🦀✨

🔒 Bu içeriği görmek için giriş yapın

 
Yanıt yazmak için giriş yapmalısınız
Forum özelliklerini kullanmak ve Level 2 üyelik satın almak için hesabınıza giriş yapın.
136,671Threads
3,307,492Messages
328,518Members
lucisanto123Latest member
Top Bottom