0Pricing
Learn Rust Coding · Leçon

Types de données primitifs et opérateurs

Explorez les types de données primitifs intégrés à Rust, tels que les entiers, les nombres à virgule flottante, les booléens et les caractères, ainsi que les opérateurs courants.

Types de données primitifs et opérateurs est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 3 leçons au total.

Introduction aux types de données primitifs

Bienvenue dans cette leçon fondamentale sur Rust ! Aujourd’hui, nous allons explorer les types de données primitifs et les opérateurs de base.

Les types primitifs sont les éléments fondamentaux du stockage des données. Ils représentent des valeurs simples comme des nombres, vrai ou faux, ou des caractères uniques.

Comprendre ces types est essentiel pour écrire du code Rust efficace et correct.

Les types entiers de Rust

Rust fournit différents types entiers adaptés à différents besoins. Ils se répartissent en deux grandes catégories :

  • Entiers signés (préfixe i) : peuvent stocker des nombres positifs et négatifs (par exemple, i8, i32, i64).
  • Entiers non signés (préfixe u) : peuvent uniquement stocker des nombres positifs ou zéro (par exemple, u8, u32, u64).

Le nombre indique la quantité de bits de stockage ; par exemple, i32 est un entier signé de 32 bits. isize et usize sont des entiers de la taille d’un pointeur, qui s’adaptent à l’architecture de votre système (32 ou 64 bits).

Déclarer des variables entières

Voyons comment déclarer et utiliser les types entiers en Rust. Remarquez que nous pouvons ajouter explicitement une annotation de type ou laisser Rust le déduire.

Essayez d’exécuter cet exemple :

fn main() {
  let signed_val: i32 = -100;
  let unsigned_val: u32 = 250;
  let inferred_int = 500; // Rust infers i32 by default
  let big_unsigned: u64 = 1_000_000_000;

  println!("Signed: {}", signed_val);
  println!("Unsigned: {}", unsigned_val);
  println!("Inferred: {}", inferred_int);
  println!("Big Unsigned: {}", big_unsigned);
}

Nombres à virgule flottante

Pour les nombres comportant une partie décimale, Rust propose les types à virgule flottante :

  • f32 : nombre flottant simple précision (32 bits).
  • f64 : nombre flottant double précision (64 bits). Il s’agit du type à virgule flottante utilisé par défaut dans Rust.

f64 est généralement privilégié pour la plupart des applications en raison de sa précision supérieure, sauf si vous êtes soumis à des contraintes particulières de mémoire ou de performances.

Déclarer des variables flottantes

Voici comment déclarer des nombres à virgule flottante. Remarquez que Rust utilise f64 par défaut si vous ne précisez pas de type.

Essayez d’exécuter cet exemple :

fn main() {
  let pi: f32 = 3.14159;
  let e = 2.718281828; // Inferred as f64
  let temperature: f64 = 98.6;

  println!("Pi (f32): {}", pi);
  println!("E (f64 inferred): {}", e);
  println!("Temperature (f64): {}", temperature);
}

Booléens et caractères

En plus des nombres, Rust possède des types pour les valeurs logiques et les caractères uniques :

  • bool : représente une valeur de vérité, soit true, soit false.
  • char : représente une valeur scalaire Unicode unique. Ainsi, un char peut être bien plus qu’un simple caractère ASCII : il peut s’agir de n’importe quelle lettre, émoticône ou symbole.

Un char utilise 4 octets de mémoire, ce qui lui permet de stocker n’importe quel caractère Unicode.

Booléens et caractères en action

Déclarons quelques variables booléennes et caractères. Remarquez les apostrophes simples utilisées pour les valeurs de type char.

Essayez d’exécuter cet exemple :

fn main() {
  let is_rust_fun: bool = true;
  let has_errors = false; // Inferred as bool
  let first_letter: char = 'R';
  let emoji_char: char = '🚀';

  println!("Is Rust fun? {}", is_rust_fun);
  println!("Has errors? {}", has_errors);
  println!("First letter: {}", first_letter);
  println!("Emoji: {}", emoji_char);
}

Opérateurs arithmétiques de base

Comme en mathématiques, Rust utilise des opérateurs pour effectuer des calculs. Voici les principaux opérateurs arithmétiques :

  • + : addition
  • - : soustraction
  • * : multiplication
  • / : division
  • % : reste (modulo)

N’oubliez pas que la division entière (par exemple, 10 / 3) tronque la partie décimale et produit un entier (3, et non 3.33).

Utiliser les opérateurs arithmétiques

Mettons ces opérateurs en pratique avec quelques nombres. Observez attentivement le comportement de la division entière !

Essayez d’exécuter cet exemple :

fn main() {
  let a = 15;
  let b = 4;

  println!("Addition: 15 + 4 = {}", a + b);
  println!("Subtraction: 15 - 4 = {}", a - b);
  println!("Multiplication: 15 * 4 = {}", a * b);
  println!("Integer Division: 15 / 4 = {}", a / b);
  println!("Remainder: 15 % 4 = {}", a % b);

  let x = 15.0;
  let y = 4.0;
  println!("Float Division: 15.0 / 4.0 = {}", x / y);
}

Quiz sur les types primitifs

Vérifiez votre compréhension des types de données primitifs et des opérateurs de base de Rust.

Récapitulatif : types primitifs et opérateurs

Excellent travail ! Vous avez découvert les types de données fondamentaux de Rust :

  • Entiers : i8, u8, i32, u32, etc., pour les nombres entiers.
  • Nombres flottants : f32 et f64 pour les nombres décimaux.
  • Booléens : bool pour true ou false.
  • Caractères : char pour les valeurs Unicode uniques.

Vous avez également exploré des opérateurs arithmétiques de base comme +, -, *, / et %. Ils constituent les fondations de raisonnements plus complexes dans vos programmes.

Questions Fréquemment Posées

La leçon « Types de données primitifs et opérateurs » est-elle gratuite ?

Oui — le texte complet de « Types de données primitifs et opérateurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Types de données primitifs et opérateurs » ?

Explorez les types de données primitifs intégrés à Rust, tels que les entiers, les nombres à virgule flottante, les booléens et les caractères, ainsi que les opérateurs courants. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.

Combien de temps prend la leçon « Types de données primitifs et opérateurs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Variables, mutabilité et masquage
  2. Types de données primitifs et opérateurs
  3. Fonctions et flux de contrôle
← Retour à Learn Rust Coding