Rust - Veri Türleri

Tür Sistemi, dil tarafından desteklenen farklı değer türlerini temsil eder. Tip Sistemi, program tarafından depolanmadan veya değiştirilmeden önce sağlanan değerlerin geçerliliğini kontrol eder. Bu, kodun beklendiği gibi davranmasını sağlar. Tip Sistemi ayrıca daha zengin kod ipuçları ve otomatik dokümantasyon da sağlar.

Rust, statik olarak yazılmış bir dildir. Rust'taki her değer belirli bir veri türündedir. Derleyici, kendisine atanan değere göre değişkenin veri türünü otomatik olarak çıkarabilir.

Bir Değişken Bildirin

Kullan let bir değişkeni bildirmek için anahtar kelime.

fn main() {
   let company_string = "TutorialsPoint";  // string type
   let rating_float = 4.5;                 // float type
   let is_growing_boolean = true;          // boolean type
   let icon_char = '♥';                    //unicode character type

   println!("company name is:{}",company_string);
   println!("company rating on 5 is:{}",rating_float);
   println!("company is growing :{}",is_growing_boolean);
   println!("company icon is:{}",icon_char);
}

Yukarıdaki örnekte, değişkenlerin veri türü, onlara atanan değerlerden çıkarılacaktır. Örneğin, Pas değişken dize veri türü atar company_string için float veri türü rating_float vb

Println! makro iki argüman alır -

Yer tutucu olan özel bir sözdizimi {}
Değişken adı veya sabit

Yer tutucu, değişkenin değeri ile değiştirilecektir

Yukarıdaki kod parçacığının çıktısı -

company name is: TutorialsPoint
company rating on 5 is:4.5
company is growing: true
company icon is: ♥

Skaler Türler

Skaler tür, tek bir değeri temsil eder. Örneğin, 10,3.14, 'c'. Rust'un dört temel skaler türü vardır.

Integer
Floating-point
Booleans
Characters

Sonraki bölümlerimizde her tür hakkında bilgi edineceğiz.

Tamsayı

Tam sayı, kesirli bileşeni olmayan bir sayıdır. Basitçe söylemek gerekirse, tamsayı veri türü tam sayıları temsil etmek için kullanılır.

Tam sayılar ayrıca İşaretli ve İşaretsiz olarak sınıflandırılabilir. İşaretli tamsayılar hem negatif hem de pozitif değerleri depolayabilir. İşaretsiz tamsayılar yalnızca pozitif değerleri depolayabilir. Tam sayı türleri aşağıda verilmişse ayrıntılı bir açıklama -

Sr.No.	Boyut	İmzalı	İmzasız
1	8 bit	i8	u8
2	16 bit	i16	u16
3	32 bit	i32	u32
4	64 bit	i64	u64
5	128 bit	i128	u128
6	Kemer	boyutlandırmak	kullanmak

Bir tamsayının boyutu kemer olabilir . Bu, veri türünün boyutunun makinenin mimarisinden türetileceği anlamına gelir . Arch boyutu olan bir tamsayı, x86 makinesinde 32 bit ve x64 makinesinde 64 bit olacaktır. Bir arch tamsayı, öncelikle bir tür koleksiyonun indekslenmesinde kullanılır.

İllüstrasyon

fn main() {
   let result = 10;    // i32 by default
   let age:u32 = 20;
   let sum:i32 = 5-15;
   let mark:isize = 10;
   let count:usize = 30;
   println!("result value is {}",result);
   println!("sum is {} and age is {}",sum,age);
   println!("mark is {} and count is {}",mark,count);
}

Çıktı aşağıda verildiği gibi olacaktır -

result value is 10
sum is -10 and age is 20
mark is 10 and count is 30

Age değerini bir kayan nokta değeriyle değiştirirseniz yukarıdaki kod bir derleme hatası döndürür .

Tamsayı Aralığı

Her bir işaretli varyant - (2 ^ (n-1) ila 2 ^ (n-1) -1 arasındaki sayıları depolayabilir; burada n, varyantın kullandığı bit sayısıdır. Örneğin, i8, - (2 ^ 7) 2 ^ 7 -1 - burada n'yi 8 ile değiştirdik .

İmzasız her varyant, 0 ile (2 ^ n) -1 arasındaki sayıları saklayabilir . Örneğin, u8, 0 ile 2 ^ 7 arasındaki sayıları depolayabilir , bu da 0 ile 255'e eşittir.

Tamsayı taşması

Bir tamsayı değişkenine atanan değer, veri türü için Rust tanımlı aralığı aştığında bir tam sayı taşması meydana gelir. Bunu bir örnekle anlayalım -

fn main() {
   let age:u8 = 255;

   // 0 to 255 only allowed for u8
   let weight:u8 = 256;   //overflow value is 0
   let height:u8 = 257;   //overflow value is 1
   let score:u8 = 258;    //overflow value is 2

   println!("age is {} ",age);
   println!("weight is {}",weight);
   println!("height is {}",height);
   println!("score is {}",score);
}

İşaretsiz u8 değişkeninin geçerli aralığı 0 ila 255'tir. Yukarıdaki örnekte, değişkenlere 255'ten büyük değerler atanmıştır (Rust'ta bir tamsayı değişkeni için üst sınır). Yürütme sırasında, yukarıdaki kod bir uyarı verecektir -warning − literal out of range for u8ağırlık, boy ve puan değişkenleri için. 255'ten sonraki taşma değerleri 0, 1, 2 vb .'den başlayacaktır. Uyarısız son çıktı aşağıda gösterildiği gibidir -

age is 255
weight is 0
height is 1
score is 2

Yüzer

Rust'taki kayan veri türü şu şekilde sınıflandırılabilir: f32 ve f64. F32 türü tek duyarlıklı bir yüzerdir ve f64 çift duyarlığa sahiptir. Varsayılan tür f64'tür. Float veri türü hakkında daha fazla bilgi edinmek için aşağıdaki örneği inceleyin.

fn main() {
   let result = 10.00;        //f64 by default
   let interest:f32 = 8.35;
   let cost:f64 = 15000.600;  //double precision
   
   println!("result value is {}",result);
   println!("interest is {}",interest);
   println!("cost is {}",cost);
}

Çıktı aşağıda gösterildiği gibi olacaktır -

interest is 8.35
cost is 15000.6

Otomatik Tip Döküm

Rust'ta otomatik tip döküme izin verilmez. Aşağıdaki kod parçacığını düşünün. Float değişkenine bir tamsayı değeri atanırinterest.

fn main() {
   let interest:f32 = 8;   // integer assigned to float variable
   println!("interest is {}",interest);
}

Derleyici bir mismatched types error aşağıda verildiği gibi.

error[E0308]: mismatched types
   --> main.rs:2:22
   |
 2 | let interest:f32=8;
   |    ^ expected f32, found integral variable
   |
   = note: expected type `f32`
      found type `{integer}`
error: aborting due to previous error(s)

Numara Ayırıcı

Büyük sayıların kolay okunabilirliği için, basamakları ayırmak için görsel ayırıcı _ alt çizgi kullanabiliriz. Yani 50.000, 50_000 olarak yazılabilir. Bu, aşağıdaki örnekte gösterilmektedir.

fn main() {
   let float_with_separator = 11_000.555_001;
   println!("float value {}",float_with_separator);
   
   let int_with_separator = 50_000;
   println!("int value {}",int_with_separator);
}

Çıktı aşağıda verilmiştir -

float value 11000.555001
int value 50000

Boole

Boole türlerinin iki olası değeri vardır - doğru veya yanlış . Kullanbool bir boole değişkeni bildirmek için anahtar kelime.

İllüstrasyon

fn main() {
   let isfun:bool = true;
   println!("Is Rust Programming Fun ? {}",isfun);
}

Yukarıdaki kodun çıktısı -

Is Rust Programming Fun ? true

Karakter

Rust'taki karakter veri türü sayıları, harfleri, Unicode'u ve özel karakterleri destekler. Kullancharbir karakter veri türü değişkeni bildirmek için anahtar sözcük. Rust'un karakter türü bir Unicode Skaler Değerini temsil eder, bu da ASCII'den çok daha fazlasını temsil edebileceği anlamına gelir. Unicode Skaler Değerler aralığıU+0000 -e U+D7FF ve U+E000 -e U+10FFFF kapsayıcı.

Karakter veri türü hakkında daha fazla bilgi edinmek için bir örnek ele alalım.

fn main() {
   let special_character = '@'; //default
   let alphabet:char = 'A';
   let emoji:char = '';
   
   println!("special character is {}",special_character);
   println!("alphabet is {}",alphabet);
   println!("emoji is {}",emoji);
}

Yukarıdaki kodun çıktısı -

special character is @
alphabet is A
emoji is