1. Accueil
  2. TUTORIELS
  3. RUST
  4. Rust les bases : Les Types de donées partie 1 Cours 4

Rust les bases : Les Types de donées partie 1 Cours 4

Nous allons continuez avec les types de données histoire de comprendre mieux certaines chose .

Rust fig dat 1 pandacodeur

 Alors il faut savoir que chaque valeur dans Rust est d’un certains type de donnée ce qui indique ainsi au Rust quel type de donnée est spécifiée comme l'on peux le voire sur la figure ci-déçue. Ainsi nous allons voir 2 sous ensemble de type de données : Les Scalaire & les Composés .

Nb : Le Rust est un Langage à typage statique cet à dire qu’il doit connaitre les types de toutes les variables au moment de la compilation.Tout de même comme j’ai évoquez dans le chapitre 2 le compilateur peut déduire le type que nous voulons utilisez en fonction bien sure de la valeur et de la manière dont nous l’utilisons , en gros en fonction du contexte.

Les Types Scalaires  

Alors un Type Scalaire va tout bonnement représenter  une valeur unique. Nous en  distinguons 4 types scalaire primaires ( les entiers , les nombres à virgule flottante , les booléens et les caractères ). Observons de plus près comment c’est types opèrent en Rust :

Les Entiers

Tout doucement commencons  par les Entiers : un Entier est  un nombre sans composante fractionnaire . En gros des nombres sans virgule. Illustrons tout ceci par un exemple en déclarants deux variables Entières notées varEnt et varEnt2 ou varEnt seras représente implicitement et varEnt2 seras représente explicitement .

 println! ("A LES ENTIERS  ") ;
       
       let monEnt = 5 ; // implicite 
       println!("Le contenue de votre variable  est :{}", monEnt );
       let monEnt2:u32 = 5 ; // explicite 
       println!("Le contenue de votre variable  est :{}", monEnt2 );
       

 

Alors cette déclaration ( déclaration explicite )de type indique que la valeur à laquelle il est associée doit être un entier non signé qui prend 32 bits d’espace. Notez que les types d’entiers signés commencent par i au lieu de u qui évoque les types d’entiers non signés . Voici un tableau qui montre les différents types d’entiers intégrés dans rust . Notez de manière indicatif que chaque variante dans les colonnes signé et Non Signé peut être utilisée pour déclarer le type d’une valeur entière.

Length ( Taille ) Signed ( Signé ) Unsigned ( Non Signé )
8-bit   i8  u8 
16-bit     i16    u16 
64-bit     i64    u64
128-bit  i128   u128     
Arch  isize  usize  


                                                      
                                                         Figure :  Classification des Types d’entiers en Rust

Pour la dernier ligne j’explique vite fait bien fait avant que vous essayez en vain de comprendre du moins pour la plupart  , Eh bien   les types isize et usize vont dépendre du type d’ordinateur sur lequel votre programme fonctionne : 64 bits si vous êtes sur une architecture 64 bits et  32 bits si vous êtes sur une architecture 32 bits notez que se servira généralement lors de l’indexation d’une collection qui seras traitez plus tard.

 

 

Les Flottants

Alors Concernant les Flottants , ce sont tout simplement des nombres à virgule flottantes ou encore des nombres a poids décimaux on en distingue deux le f32 et le f64 qui sont respectivement sur 32 bits et 64 bits . Le type par défaut est f64 bits , mais le f32 est plus rapide que celui-ci du moins de mon point de vue.
Illustrations :

 

println! ("B LES FLOTTANTS  ") ;
       
       let monFlot = 5.1 ; // implicite 
       println!("Le contenue de votre variable  est :{}", monFlot );
       let monFlot2:f32 = 5.1 ; // explicite 
       println!("Le contenue de votre variable  est :{}", monFlot2 );

 

Les Booléens

Alors un type Booleen est un type de variable à deux états, destiné à représenter les valeurs de vérité de la logique et l'algèbre booléenne. Un rust un booléen à deux valeurs possibles  true ou false , ils ont une taillle d’un octet et sont repésentés par le mot clé Bool .
Illustration :

println! ("C LES BOOLEENS  ") ;
       
       let monBool = false ; // implicite 
       println!("Le contenue de votre variable  est :{}", monBool);
       let monBool2:bool = true ; // explicite 
       println!("Le contenue de votre variable  est :{}", monBool2 );
       

 

Les Caractères

Le type caractère en rust est le type alphabétique le plus primitif de notre langue en gros les lettres de l’alphabet quoi !
Illustration :

   println! ("D LES  CARACTERES  ") ;
       
       let  monCar = 'j' ; // implicite 
       println!("Le contenue de votre variable  est :{}", monCar );
       let monCar2 = ' ' ; // explicite 
       println!("Le contenue de votre variable  est :{}", monCar2 );
       let monCar2 = '  ' ; // explicite 
       println!("Le contenue de votre variable  est :{}", monCar2 );
       

 

PREC Suiv

  • 1 vote. Moyenne 5 sur 5.

Commentaires

  • kana
    • 1. kana Le 25/01/2021
    la suite des cours svp !!!

Ajouter un commentaire

Aperçu
 

Pandacodeur 8 mars