LabEx
EntrerRejoindre

Variables et types de données en C++

C++Beginner
Pratiquer maintenant

Introduction

Dans ce laboratoire, vous apprendrez à travailler avec des variables et des types de données en C++. Vous explorerez différentes tailles de variables entières, initialiserez des variables de type float et double, déclarerez des variables de type caractère et chaîne de caractères, effectuerez des conversions de type (type casting), définirez des constantes, utiliserez des variables booléennes et vérifierez la taille mémoire de différents types de données. De plus, vous apprendrez à gérer les situations de dépassement d'entier (integer overflow). Cette expérience pratique vous fournira une solide base pour la gestion des données dans vos projets de programmation en C++.

Déclarer des variables entières de tailles différentes (short, int, long)

Dans cette étape, vous allez apprendre à propos des différents types de variables entières en C++ et à déclarer des variables avec des tailles mémoire variables. C++ propose plusieurs types entiers pour vous aider à choisir le stockage le plus approprié pour vos données.

Ouvrez le WebIDE et créez un nouveau fichier appelé integer_variables.cpp dans le répertoire ~/project :

touch ~/project/integer_variables.cpp

Ajoutez le code suivant au fichier integer_variables.cpp :

#include <iostream>

int main() {
    // Déclaration d'un entier court (généralement 2 octets)
    short smallNumber = 32767;

    // Déclaration d'un entier standard (généralement 4 octets)
    int regularNumber = 2147483647;

    // Déclaration d'un entier long (généralement 4 ou 8 octets)
    long largeNumber = 9223372036854775807L;

    // Affichage des valeurs des différents types entiers
    std::cout << "Short Integer: " << smallNumber << std::endl;
    std::cout << "Regular Integer: " << regularNumber << std::endl;
    std::cout << "Long Integer: " << largeNumber << std::endl;

    return 0;
}

Analysons les types entiers :

  1. short :

    • Plus petit type entier
    • Utilise généralement 2 octets de mémoire
    • Plage de valeurs : -32 768 à 32 767

  2. int :

    • Type entier standard
    • Utilise généralement 4 octets de mémoire
    • Plage de valeurs : -2 147 483 648 à 2 147 483 647

  3. long :

    • Type entier plus grand
    • Peut être de 4 ou 8 octets selon le système
    • Plage de valeurs : -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807

Compilez et exécutez le programme :

g++ integer_variables.cpp -o integer_variables
./integer_variables

Exemple de sortie :

Short Integer: 32767
Regular Integer: 2147483647
Long Integer: 9223372036854775807

Points clés à retenir :

  • Choisissez le type entier en fonction de la plage de valeurs que vous devez stocker.
  • Le suffixe L pour les entiers longs garantit une interprétation correcte du type.
  • Différents systèmes peuvent avoir des tailles mémoire légèrement différentes pour ces types.

Comprendre les types entiers et leurs plages de valeurs est fondamental pour la programmation en C++. Ces types offrent différentes allocations mémoire pour stocker efficacement diverses plages de nombres entiers. Visualisons comment ces types s'insèrent dans le système de types plus large de C++ :

graph LR
    A[C++ Data Types] --> B[Fundamental Types]
    A --> C[Derived Types]

    B --> D[Integer Types]
    B --> E[Floating-Point Types]
    B --> F[Character Types]
    B --> G[Boolean]

    D --> D1[short]
    D --> D2[int]
    D --> D3[long]
    D --> D4[long long]

    E --> E1[float]
    E --> E2[double]
    E --> E3[long double]

    F --> F1[char]
    F --> F2[wchar_t]

    C --> H[Arrays]
    C --> I[Pointers]
    C --> J[References]
    C --> K[std::string]

    style A fill:#f9f,stroke:#333,stroke-width:2px
    style B fill:#bbf,stroke:#333
    style C fill:#bbf,stroke:#333

Nous apprendrons à propos des types à virgule flottante, des types caractères et des types booléens dans les étapes suivantes.

Initialiser des variables flottantes (float et double) avec des points décimaux

Dans cette étape, vous allez apprendre à propos des variables à virgule flottante en C++, plus précisément les types float et double, qui vous permettent de travailler avec des nombres décimaux. Ces types sont essentiels pour représenter des nombres avec des parties fractionnaires.

Ouvrez le WebIDE et créez un nouveau fichier appelé floating_point.cpp dans le répertoire ~/project :

touch ~/project/floating_point.cpp

Ajoutez le code suivant au fichier floating_point.cpp :

#include <iostream>
#include <iomanip>

int main() {
    // Déclaration et initialisation de variables de type float
    float smallDecimal = 3.14f;  // Le suffixe 'f' indique un type float
    float scientificNotation = 2.5e3f;  // 2.5 × 10^3 = 2500.0

    // Déclaration et initialisation de variables de type double
    double preciseDecimal = 3.14159265359;
    double largeDecimal = 1.23456789e10;  // 12 345 678 900.0

    // Paramétrage de la précision pour l'affichage des nombres décimaux
    std::cout << std::fixed << std::setprecision(4);

    // Affichage des valeurs de type float
    std::cout << "Float Values:" << std::endl;
    std::cout << "Small Decimal: " << smallDecimal << std::endl;
    std::cout << "Scientific Notation: " << scientificNotation << std::endl;

    // Affichage des valeurs de type double
    std::cout << "\nDouble Values:" << std::endl;
    std::cout << "Precise Decimal: " << preciseDecimal << std::endl;
    std::cout << "Large Decimal: " << largeDecimal << std::endl;

    return 0;
}

Analysons les types à virgule flottante :

  1. float :

    • Type à virgule flottante à simple précision
    • Utilise généralement 4 octets de mémoire
    • Moins précis, adapté pour les calculs décimaux de base
    • Utilisez le suffixe 'f' lors de l'initialisation

  2. double :

    • Type à virgule flottante à double précision
    • Utilise généralement 8 octets de mémoire
    • Plus précis, préféré pour la plupart des calculs décimaux
    • Peut représenter des nombres décimaux plus grands et plus précis

Compilez et exécutez le programme :

g++ floating_point.cpp -o floating_point
./floating_point

Exemple de sortie :

Float Values:
Small Decimal: 3.1416
Scientific Notation: 2500.0000

Double Values:
Precise Decimal: 3.1416
Large Decimal: 12345678900.0000

Points clés à retenir :

  • Utilisez float pour les nombres décimaux plus petits et moins précis.
  • Utilisez double pour les calculs plus précis.
  • Le suffixe 'f' est important pour les littéraux de type float.
  • La notation scientifique permet de représenter des nombres très grands ou très petits.
  • std::fixed et std::setprecision() vous aident à contrôler l'affichage des nombres décimaux.

Déclarer et initialiser des variables de caractères avec des guillemets simples

Dans cette étape, vous allez apprendre à propos des variables de type caractère en C++, qui sont utilisées pour stocker un seul caractère et sont déclarées en utilisant des apostrophes simples. Les caractères sont des types de données fondamentaux qui représentent des lettres, des chiffres ou des symboles individuels.

Ouvrez le WebIDE et créez un nouveau fichier appelé character_variables.cpp dans le répertoire ~/project :

touch ~/project/character_variables.cpp

Ajoutez le code suivant au fichier character_variables.cpp :

#include <iostream>

int main() {
    // Déclaration et initialisation de variables de type caractère
    char letter = 'A';
    char number = '7';
    char symbol = '$';

    // Affichage des valeurs des caractères
    std::cout << "Letter: " << letter << std::endl;
    std::cout << "Number: " << number << std::endl;
    std::cout << "Symbol: " << symbol << std::endl;

    // Exemple d'opération arithmétique sur les caractères
    char nextLetter = letter + 1;
    std::cout << "Next Letter: " << nextLetter << std::endl;

    // Valeur ASCII des caractères
    std::cout << "ASCII value of 'A': " << (int)letter << std::endl;

    return 0;
}

Analysons les variables de type caractère :

  1. Déclaration :

    • Utilisez le mot-clé char
    • Toujours initialisées avec des apostrophes simples ''
    • Peuvent stocker un seul caractère

  2. Types de caractères :

    • Lettres : 'A', 'b', 'Z'
    • Chiffres : '0', '7', '9'
    • Symboles : '$', '@', '#'

  3. Opérations arithmétiques sur les caractères :

    • Les caractères peuvent être manipulés à l'aide d'opérations entières
    • Chaque caractère a une valeur ASCII sous-jacente

Compilez et exécutez le programme :

g++ character_variables.cpp -o character_variables
./character_variables

Exemple de sortie :

Letter: A
Number: 7
Symbol: $
Next Letter: B
ASCII value of 'A': 65

Points clés à retenir :

  • Utilisez des apostrophes simples '' pour les littéraux de type caractère.
  • Les caractères sont stockés sous forme de valeurs numériques (ASCII).
  • Vous pouvez effectuer des opérations arithmétiques sur les caractères.
  • Chaque caractère occupe 1 octet de mémoire.

Créer des variables chaîne de caractères en utilisant std::string

Dans cette étape, vous allez apprendre à créer et manipuler des variables de type chaîne de caractères en utilisant la classe std::string en C++. Les chaînes de caractères sont des séquences de caractères qui vous permettent de travailler plus facilement avec du texte par rapport aux tableaux de caractères.

Ouvrez le WebIDE et créez un nouveau fichier appelé string_variables.cpp dans le répertoire ~/project :

touch ~/project/string_variables.cpp

Ajoutez le code suivant au fichier string_variables.cpp :

#include <iostream>
#include <string>

int main() {
    // Déclaration et initialisation de variables de type chaîne de caractères
    std::string greeting = "Hello, World!";
    std::string name = "John Doe";
    std::string empty_string;

    // Affichage des variables de type chaîne de caractères
    std::cout << "Greeting: " << greeting << std::endl;
    std::cout << "Name: " << name << std::endl;

    // Concaténation de chaînes de caractères
    std::string welcome = greeting + " Welcome, " + name;
    std::cout << "Welcome Message: " << welcome << std::endl;

    // Longueur de la chaîne de caractères
    std::cout << "Greeting length: " << greeting.length() << std::endl;

    // Accès à un caractère individuel
    std::cout << "First character of name: " << name[0] << std::endl;

    // Modification de chaînes de caractères
    name = "Jane Smith";
    std::cout << "Updated Name: " << name << std::endl;

    return 0;
}

Analysons les opérations sur les chaînes de caractères :

  1. Déclaration :

    • Utilisez #include <string> pour accéder aux fonctionnalités des chaînes de caractères
    • Déclarez avec le mot-clé std::string
    • Peuvent être initialisées avec du texte ou laissées vides

  2. Opérations sur les chaînes de caractères :

    • Concaténation avec l'opérateur +
    • Obtenir la longueur avec la méthode .length()
    • Accéder aux caractères avec l'index []

Compilez et exécutez le programme :

g++ string_variables.cpp -o string_variables
./string_variables

Exemple de sortie :

Greeting: Hello, World!
Name: John Doe
Welcome Message: Hello, World! Welcome, John Doe
Greeting length: 13
First character of name: J
Updated Name: Jane Smith

Points clés à retenir :

  • std::string est plus flexible que les tableaux de caractères.
  • Les chaînes de caractères peuvent être facilement modifiées et manipulées.
  • Utilisez .length() pour obtenir la taille de la chaîne de caractères.
  • Les chaînes de caractères peuvent être concaténées avec l'opérateur +.

Conversion entre différents types numériques à l'aide du casting de type

Dans cette étape, vous allez apprendre à propos du transtypage (type casting) en C++, qui vous permet de convertir des valeurs entre différents types numériques. Le transtypage est essentiel lorsque vous avez besoin de changer le type de données d'une variable sans perdre la valeur originale.

Ouvrez le WebIDE et créez un nouveau fichier appelé type_casting.cpp dans le répertoire ~/project :

touch ~/project/type_casting.cpp

Ajoutez le code suivant au fichier type_casting.cpp :

#include <iostream>

int main() {
    // Transtypage implicite (conversion automatique)
    int intValue = 10;
    double doubleValue = intValue;  // Convertit automatiquement un int en double
    std::cout << "Implicit Conversion (int to double): " << doubleValue << std::endl;

    // Transtypage explicite (conversion manuelle)
    double pi = 3.14159;
    int truncatedPi = (int)pi;  // Transtypage en style C, tronque la partie décimale
    std::cout << "Explicit Conversion (double to int): " << truncatedPi << std::endl;

    // Transtypage statique pour la conversion de type
    float floatValue = 7.5f;
    int roundedValue = static_cast<int>(floatValue);
    std::cout << "Static Cast (float to int): " << roundedValue << std::endl;

    // Conversion entre types numériques avec perte potentielle de données
    long largeNumber = 1000000;
    short smallNumber = static_cast<short>(largeNumber);
    std::cout << "Large to Small Type Conversion: " << smallNumber << std::endl;

    // Mélange de différents types numériques dans des calculs
    int a = 5;
    double b = 2.5;
    double result = a + b;  // Conversion implicite de int en double
    std::cout << "Mixed Type Calculation: " << result << std::endl;

    return 0;
}

Analysons le transtypage :

  1. Transtypage implicite :

    • Conversion automatique entre des types compatibles
    • Se produit sans intervention du programmeur
    • Généralement sûr lors de la conversion vers un type plus grand

  2. Transtypage explicite :

    • Conversion de type manuelle
    • Utilise static_cast<>() ou la syntaxe en style C (type)
    • Peut entraîner une perte de données ou des résultats inattendus

Compilez et exécutez le programme :

g++ type_casting.cpp -o type_casting
./type_casting

Exemple de sortie :

Implicit Conversion (int to double): 10
Explicit Conversion (double to int): 3
Static Cast (float to int): 7
Large to Small Type Conversion: 16960
Mixed Type Calculation: 7.5

Points clés à retenir :

  • Soyez prudent lors du transtypage vers des types plus petits.
  • Utilisez static_cast<>() pour des conversions plus sûres et plus explicites.
  • Comprenez la perte potentielle de données lors des conversions.
  • Les conversions implicites peuvent se produire automatiquement dans les calculs.

Définir des constantes à l'aide du mot clé const

Dans cette étape, vous allez apprendre à définir des constantes en C++ en utilisant le mot-clé const. Les constantes sont des valeurs qui ne peuvent pas être modifiées après l'initialisation, offrant ainsi un moyen de créer des variables immuables qui protègent les données contre des modifications non intentionnelles.

Ouvrez le WebIDE et créez un nouveau fichier appelé constants.cpp dans le répertoire ~/project :

touch ~/project/constants.cpp

Ajoutez le code suivant au fichier constants.cpp :

#include <iostream>

int main() {
    // Définition de constantes avec le mot-clé const
    const int MAX_USERS = 100;
    const double PI = 3.14159;
    const char GRADE_SEPARATOR = '-';

    // Exemple d'utilisation des constantes
    std::cout << "Maximum Users: " << MAX_USERS << std::endl;
    std::cout << "Value of PI: " << PI << std::endl;
    std::cout << "Grade Separator: " << GRADE_SEPARATOR << std::endl;

    // Convention de nommage : les constantes utilisent généralement des majuscules
    const int DAYS_IN_WEEK = 7;
    const std::string WELCOME_MESSAGE = "Welcome to C++ Programming!";

    std::cout << "Days in a Week: " << DAYS_IN_WEEK << std::endl;
    std::cout << "Welcome Message: " << WELCOME_MESSAGE << std::endl;

    // Tentative de modification d'une constante (causera une erreur de compilation)
    // Décommentez la ligne suivante pour voir l'erreur
    // MAX_USERS = 200;  // Cela causerait une erreur à la compilation

    return 0;
}

Analysons les constantes :

  1. Déclaration :

    • Utilisez le mot-clé const avant le type
    • Doit être initialisée lors de la déclaration
    • Ne peut pas être modifiée après l'initialisation

  2. Bonnes pratiques :

    • Utilisez des majuscules pour les noms de constantes
    • Fonctionne avec tous les types de données
    • Aide à prévenir les modifications accidentelles

Compilez et exécutez le programme :

g++ constants.cpp -o constants
./constants

Exemple de sortie :

Maximum Users: 100
Value of PI: 3.14159
Grade Separator: -
Days in a Week: 7
Welcome Message: Welcome to C++ Programming!

Points clés à retenir :

  • const crée une variable immuable.
  • Les constantes doivent être initialisées lors de la déclaration.
  • Aide à rendre le code plus lisible et plus sûr.
  • Empêche les modifications non intentionnelles de valeurs importantes.

Utiliser des variables booléennes pour les conditions Vrai/Faux

Dans cette étape, vous allez apprendre à propos des variables booléennes en C++, qui représentent des valeurs vraies ou fausses. Les booléens sont fondamentaux pour créer une logique conditionnelle et prendre des décisions dans vos programmes.

Ouvrez le WebIDE et créez un nouveau fichier appelé boolean_variables.cpp dans le répertoire ~/project :

touch ~/project/boolean_variables.cpp

#include <iostream>

int main() {
    // Déclaration de variables booléennes
    bool isStudent = true;
    bool hasPassedExam = false;

    // Affichage des valeurs booléennes
    std::cout << "Is Student: " << std::boolalpha << isStudent << std::endl;
    std::cout << "Passed Exam: " << hasPassedExam << std::endl;

    // Opérations de comparaison qui donnent des résultats booléens
    int age = 20;
    bool isAdult = (age >= 18);
    std::cout << "Is Adult: " << isAdult << std::endl;

    // Opérations logiques
    bool hasScholarship = true;
    bool canEnroll = isStudent && isAdult;
    std::cout << "Can Enroll: " << canEnroll << std::endl;

    // Négation
    bool isUnemployed =!hasPassedExam;
    std::cout << "Is Unemployed: " << isUnemployed << std::endl;

    // Instruction conditionnelle utilisant un booléen
    if (isStudent && hasPassedExam) {
        std::cout << "Congratulations! You can proceed to the next level." << std::endl;
    } else {
        std::cout << "You need to improve your academic performance." << std::endl;
    }

    return 0;
}

Analysons les variables booléennes :

  1. Déclaration :

    • Utilisez le mot-clé bool
    • Ne peut être que true ou false
    • Utile pour la logique conditionnelle

  2. Opérations :

    • Les opérateurs de comparaison produisent des résultats booléens
    • ET logique &&
    • OU logique ||
    • Négation !

Compilez et exécutez le programme :

g++ boolean_variables.cpp -o boolean_variables
./boolean_variables

Exemple de sortie :

Is Student: true
Passed Exam: false
Is Adult: true
Can Enroll: true
Is Unemployed: true
You need to improve your academic performance.

Points clés à retenir :

  • Les booléens représentent des conditions vraies/fausses.
  • Utilisés dans les comparaisons et les opérations logiques.
  • Essentiels pour la prise de décision dans les programmes.
  • std::boolalpha affiche "true"/"false" au lieu de 1/0.

Vérifier la taille mémoire des différents types de données à l'aide de sizeof()

Dans cette étape, vous allez apprendre à propos de l'opérateur sizeof() en C++, qui vous permet de déterminer la taille mémoire de différents types de données. Comprendre l'allocation mémoire est crucial pour une programmation efficace et une gestion mémoire optimale.

Ouvrez le WebIDE et créez un nouveau fichier appelé sizeof_operator.cpp dans le répertoire ~/project :

touch ~/project/sizeof_operator.cpp

#include <iostream>

int main() {
    // Vérification de la taille mémoire des types entiers
    std::cout << "Integer Types Memory Size:" << std::endl;
    std::cout << "short: " << sizeof(short) << " bytes" << std::endl;
    std::cout << "int: " << sizeof(int) << " bytes" << std::endl;
    std::cout << "long: " << sizeof(long) << " bytes" << std::endl;
    std::cout << "long long: " << sizeof(long long) << " bytes" << std::endl;

    // Vérification de la taille mémoire des types à virgule flottante
    std::cout << "\nFloating-Point Types Memory Size:" << std::endl;
    std::cout << "float: " << sizeof(float) << " bytes" << std::endl;
    std::cout << "double: " << sizeof(double) << " bytes" << std::endl;
    std::cout << "long double: " << sizeof(long double) << " bytes" << std::endl;

    // Vérification de la taille mémoire des types caractères et booléens
    std::cout << "\nOther Types Memory Size:" << std::endl;
    std::cout << "char: " << sizeof(char) << " bytes" << std::endl;
    std::cout << "bool: " << sizeof(bool) << " bytes" << std::endl;

    // Vérification de la taille mémoire de variables spécifiques
    int intVar = 42;
    double doubleVar = 3.14;
    char charVar = 'A';

    std::cout << "\nVariable Memory Size:" << std::endl;
    std::cout << "intVar: " << sizeof(intVar) << " bytes" << std::endl;
    std::cout << "doubleVar: " << sizeof(doubleVar) << " bytes" << std::endl;
    std::cout << "charVar: " << sizeof(charVar) << " bytes" << std::endl;

    return 0;
}

Analysons l'opérateur sizeof() :

  1. But :

    • Détermine la taille mémoire des types de données
    • Retourne la taille en octets
    • Utile pour comprendre l'allocation mémoire

  2. Utilisation :

    • Peut être utilisé avec des types de données
    • Peut être utilisé avec des variables
    • Aide à comprendre les besoins mémoire

Compilez et exécutez le programme :

g++ sizeof_operator.cpp -o sizeof_operator
./sizeof_operator

Exemple de sortie :

Integer Types Memory Size:
short: 2 bytes
int: 4 bytes
long: 8 bytes
long long: 8 bytes

Floating-Point Types Memory Size:
float: 4 bytes
double: 8 bytes
long double: 16 bytes

Other Types Memory Size:
char: 1 bytes
bool: 1 bytes

Variable Memory Size:
intVar: 4 bytes
doubleVar: 8 bytes
charVar: 1 bytes

Points clés à retenir :

  • sizeof() retourne la taille mémoire en octets.
  • Les tailles mémoire peuvent varier d'un système à l'autre.
  • Aide à comprendre les besoins mémoire des types de données.
  • Utile pour la gestion mémoire de bas niveau.

Gérer les dépassements de capacité des entiers

Dans cette étape, vous allez apprendre à propos du dépassement d'entier (integer overflow), une situation qui se produit lorsqu'un calcul produit une valeur qui dépasse la limite maximale d'un type entier. Comprendre et prévenir le dépassement est crucial pour écrire des programmes C++ robustes et fiables.

Ouvrez le WebIDE et créez un nouveau fichier appelé integer_overflow.cpp dans le répertoire ~/project :

touch ~/project/integer_overflow.cpp

#include <iostream>
#include <limits>

int main() {
    // Démonstration du dépassement d'entier avec un short int
    short smallInt = 32767;  // Valeur maximale pour un short
    std::cout << "Original Value: " << smallInt << std::endl;

    // Le dépassement se produit lors de l'incrémentation au-delà de la valeur maximale
    smallInt++;
    std::cout << "After Overflow: " << smallInt << std::endl;

    // Utilisation d'entiers non signés pour prévenir le dépassement négatif
    unsigned int positiveOnly = 0;
    std::cout << "Unsigned Integer Start: " << positiveOnly << std::endl;

    // La décrémentation d'un entier non signé provoque un rebouclage
    positiveOnly--;
    std::cout << "Unsigned Integer Wrap-around: " << positiveOnly << std::endl;

    // Vérification des limites des entiers
    std::cout << "\nInteger Type Limits:" << std::endl;
    std::cout << "Short Max: " << std::numeric_limits<short>::max() << std::endl;
    std::cout << "Short Min: " << std::numeric_limits<short>::min() << std::endl;

    // Méthode d'incrémentation sûre
    try {
        if (smallInt < std::numeric_limits<short>::max()) {
            smallInt++;
            std::cout << "Safe Increment: " << smallInt << std::endl;
        } else {
            std::cout << "Cannot increment further" << std::endl;
        }
    } catch (const std::overflow_error& e) {
        std::cout << "Overflow Error: " << e.what() << std::endl;
    }

    return 0;
}

Analysons le dépassement d'entier :

  1. Caractéristiques du dépassement :

    • Se produit lorsque la valeur dépasse la limite maximale du type
    • Peut causer des résultats inattendus
    • Comportement différent pour les types signés et non signés

  2. Stratégies de prévention :

    • Vérifiez les limites avant les calculs
    • Utilisez des types entiers plus grands
    • Utilisez des types non signés pour les valeurs non négatives
    • Mettez en œuvre une vérification de plage

Compilez et exécutez le programme :

g++ integer_overflow.cpp -o integer_overflow
./integer_overflow

Exemple de sortie :

Original Value: 32767
After Overflow: -32768
Unsigned Integer Start: 0
Unsigned Integer Wrap-around: 4294967295

Integer Type Limits:
Short Max: 32767
Short Min: -32768
Safe Increment: -32767

Points clés à retenir :

  • Le dépassement d'entier peut entraîner des résultats inattendus.
  • Les différents types ont des comportements de dépassement différents.
  • Vérifiez toujours les plages de valeurs avant les calculs.
  • Utilisez des types de données appropriés pour vos calculs.

Résumé

Dans ce laboratoire, vous avez appris à propos des différents types de données en C++ et à les manipuler. Vous avez commencé par déclarer des variables entières de différentes tailles, notamment short, int et long, et exploré leurs plages respectives. Ensuite, vous avez initialisé des variables à virgule flottante, telles que float et double, avec des nombres décimaux. Vous avez également appris à déclarer et initialiser des variables caractères en utilisant des guillemets simples, ainsi qu'à créer des variables de type chaîne de caractères en utilisant la classe std::string. De plus, vous avez exploré le transtypage (type casting) pour convertir entre différents types numériques, défini des constantes en utilisant le mot-clé const et manipulé des variables booléennes pour les conditions vraies/fausses. Enfin, vous avez utilisé l'opérateur sizeof() pour vérifier la taille mémoire de divers types de données et géré les situations de dépassement d'entier (integer overflow).

Connexe C++ Cours
Programmation en C++ pour les débutants

Programmation en C++ pour les débutants

cpp
Création du Système solaire en OpenGL

Création du Système solaire en OpenGL

cpp
Création d'un simple conteneur Docker en C++

Création d'un simple conteneur Docker en C++

cpp