Manipuler les tableaux et les chaînes de caractères en C++

Introduction

Dans ce laboratoire (lab), vous apprendrez à manipuler les tableaux (arrays) et les chaînes de caractères (strings) en C++. Le laboratoire couvre une gamme de sujets, notamment la création et l'initialisation de tableaux unidimensionnels, l'accès et la modification des éléments de tableau, la mise en œuvre de tableaux bidimensionnels, le travail avec les chaînes de caractères au style C et la classe String, le tri des éléments de tableau, la recherche linéaire et la gestion de l'entrée de chaînes de caractères avec getline(). Grâce à ces exercices pratiques, vous développerez une bonne compréhension des opérations fondamentales sur les tableaux et les chaînes de caractères en programmation C++.

Créer et initialiser des tableaux unidimensionnels

Dans cette étape, vous apprendrez à créer et initialiser des tableaux unidimensionnels (one-dimensional arrays) en C++. Les tableaux sont des structures de données fondamentales qui vous permettent de stocker plusieurs éléments du même type dans une zone mémoire contiguë.

Ouvrez le WebIDE et créez un nouveau fichier appelé arrays_intro.cpp dans le répertoire ~/project. Nous allons explorer différentes façons d'initialiser des tableaux.

touch ~/project/arrays_intro.cpp

Ajoutez le code suivant au fichier arrays_intro.cpp :

#include <iostream>

int main() {
    // Méthode 1 : Déclarer et initialiser un tableau avec une taille spécifique
    int numbers[5] = {10, 20, 30, 40, 50};

    // Méthode 2 : Laisser le compilateur déterminer la taille du tableau
    int scores[] = {85, 92, 78, 95, 88};

    // Méthode 3 : Initialiser le tableau avec la valeur par défaut zéro
    int zeros[6] = {0};

    // Méthode 4 : Créer un tableau et l'initialiser plus tard
    int temperatures[4];
    temperatures[0] = 72;
    temperatures[1] = 68;
    temperatures[2] = 75;
    temperatures[3] = 80;

    // Afficher les éléments du tableau
    std::cout << "Première méthode - tableau numbers :" << std::endl;
    for (int i = 0; i < 5; i++) {
        std::cout << "Élément " << i << ": " << numbers[i] << std::endl;
    }

    return 0;
}

Décortiquons l'initialisation des tableaux :

1. int numbers[5] = {10, 20, 30, 40, 50}; : Définir explicitement la taille du tableau et initialiser tous les éléments
2. int scores[] = {85, 92, 78, 95, 88}; : Laisser le compilateur déterminer la taille du tableau
3. int zeros[6] = {0}; : Initialiser tous les éléments à zéro
4. Affecter manuellement des valeurs en utilisant l'index temperatures[index] = value

Compilez et exécutez le programme :

g++ arrays_intro.cpp -o arrays_intro
./arrays_intro

Exemple de sortie :

Première méthode - tableau numbers :
Élément 0: 10
Élément 1: 20
Élément 2: 30
Élément 3: 40
Élément 4: 50

Points clés sur les tableaux :

• Les tableaux ont une taille fixe une fois déclarés
• L'indexation des tableaux commence à 0
• Vous pouvez initialiser des tableaux de plusieurs façons
• Assurez-vous toujours de ne pas dépasser les limites du tableau

Accéder et modifier les éléments d'un tableau à l'aide de l'index

Dans cette étape, vous apprendrez à accéder et modifier les éléments d'un tableau (array) en utilisant leur index en C++. En vous appuyant sur l'étape précédente d'initialisation des tableaux, nous allons explorer comment interagir avec les éléments individuels d'un tableau.

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

touch ~/project/array_indexing.cpp

Ajoutez le code suivant au fichier array_indexing.cpp :

#include <iostream>

int main() {
    // Créer un tableau des scores des étudiants
    int scores[5] = {85, 92, 78, 95, 88};

    // Accéder aux éléments du tableau par index
    std::cout << "Score du premier étudiant : " << scores[0] << std::endl;
    std::cout << "Score du troisième étudiant : " << scores[2] << std::endl;

    // Modifier les éléments du tableau
    std::cout << "Score original du deuxième étudiant : " << scores[1] << std::endl;
    scores[1] = 96; // Mettre à jour le score du deuxième étudiant
    std::cout << "Score mis à jour du deuxième étudiant : " << scores[1] << std::endl;

    // Calculer la somme des éléments du tableau
    int total_score = 0;
    for (int i = 0; i < 5; i++) {
        total_score += scores[i];
    }
    std::cout << "Score total de la classe : " << total_score << std::endl;

    // Calculer la moyenne des scores
    double average_score = static_cast<double>(total_score) / 5;
    std::cout << "Moyenne des scores de la classe : " << average_score << std::endl;

    return 0;
}

Points clés sur l'indexation des tableaux :

• Les indices des tableaux commencent à 0
• Utilisez les crochets [] pour accéder aux éléments
• Vous pouvez lire et modifier les éléments en utilisant leur index
• Faites attention à ne pas accéder à des indices en dehors des limites du tableau

Compilez et exécutez le programme :

g++ array_indexing.cpp -o array_indexing
./array_indexing

Exemple de sortie :

Score du premier étudiant : 85
Score du troisième étudiant : 78
Score original du deuxième étudiant : 92
Score mis à jour du deuxième étudiant : 96
Score total de la classe : 442
Moyenne des scores de la classe : 88.4

Règles importantes d'indexation :

• Le premier élément se trouve à l'index 0
• Le dernier élément se trouve à l'index (taille du tableau - 1)
• L'accès à un index en dehors de la plage du tableau entraîne un comportement indéfini

Implémenter des tableaux bidimensionnels pour des matrices

Dans cette étape, vous apprendrez à créer et manipuler des tableaux bidimensionnels (two-dimensional arrays) en C++. Les tableaux bidimensionnels ressemblent à des tableaux ou des matrices avec des lignes et des colonnes, ce qui vous permet de stocker et de manipuler des données dans une structure en grille.

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

touch ~/project/matrix_arrays.cpp

Ajoutez le code suivant au fichier matrix_arrays.cpp :

#include <iostream>

int main() {
    // Méthode 1 : Déclarer et initialiser une matrice 3x3
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // Méthode 2 : Déclarer la matrice et l'initialiser plus tard
    int grades[2][4];
    grades[0][0] = 85;
    grades[0][1] = 92;
    grades[0][2] = 78;
    grades[0][3] = 95;
    grades[1][0] = 88;
    grades[1][1] = 90;
    grades[1][2] = 82;
    grades[1][3] = 87;

    // Afficher la première matrice
    std::cout << "Première matrice :" << std::endl;
    for (int row = 0; row < 3; row++) {
        for (int col = 0; col < 3; col++) {
            std::cout << matrix[row][col] << " ";
        }
        std::cout << std::endl;
    }

    // Afficher la matrice des notes
    std::cout << "\nMatrice des notes :" << std::endl;
    for (int row = 0; row < 2; row++) {
        for (int col = 0; col < 4; col++) {
            std::cout << grades[row][col] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

Points clés sur les tableaux bidimensionnels :

• Utilisez deux indices pour accéder aux éléments : array[row][column]
• Le premier indice représente la ligne, le deuxième indice représente la colonne
• Peuvent être initialisés de plusieurs façons
• Des boucles imbriquées sont généralement utilisées pour parcourir les lignes et les colonnes

Compilez et exécutez le programme :

g++ matrix_arrays.cpp -o matrix_arrays
./matrix_arrays

Exemple de sortie :

Première matrice :
1 2 3
4 5 6
7 8 9

Matrice des notes :
85 92 78 95
88 90 82 87

Concepts importants des tableaux bidimensionnels :

• Les tableaux peuvent avoir plus de deux dimensions
• Chaque ligne peut avoir un nombre différent de colonnes
• Soyez toujours prudent avec les limites des tableaux pour éviter les erreurs

Initialiser des chaînes de caractères au style C avec un terminateur nul

Dans cette étape, vous apprendrez à propos des chaînes de caractères au style C (C-style strings) et de l'importance du terminateur nul en C++. Les chaînes de caractères au style C sont des tableaux de caractères qui se terminent par un caractère spécial '\0' pour marquer la fin de la chaîne.

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

touch ~/project/c_style_strings.cpp

Ajoutez le code suivant au fichier c_style_strings.cpp :

#include <iostream>
#include <cstring>

int main() {
    // Méthode 1 : Initialiser une chaîne avec un terminateur nul explicite
    char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
    std::cout << "Salutation : " << greeting << std::endl;

    // Méthode 2 : Initialiser comme une chaîne littérale (ajoute automatiquement le terminateur nul)
    char name[] = "John Doe";
    std::cout << "Nom : " << name << std::endl;

    // Méthode 3 : Déclarer avec une taille fixe et initialiser
    char message[20] = "Welcome to C++!";
    std::cout << "Message : " << message << std::endl;

    // Démontrer la longueur de la chaîne
    std::cout << "Longueur du nom : " << strlen(name) << std::endl;

    // Calcul manuel de la longueur de la chaîne
    int length = 0;
    while (name[length]!= '\0') {
        length++;
    }
    std::cout << "Longueur manuelle du nom : " << length << std::endl;

    return 0;
}

Points clés sur les chaînes de caractères au style C :

• Le terminateur nul '\0' marque la fin de la chaîne
• Allouez toujours un caractère supplémentaire pour le terminateur nul
• Les chaînes littérales ajoutent automatiquement le terminateur nul
• La fonction strlen() compte les caractères avant le terminateur nul

Compilez et exécutez le programme :

g++ c_style_strings.cpp -o c_style_strings
./c_style_strings

Exemple de sortie :

Salutation : Hello
Nom : John Doe
Message : Welcome to C++!
Longueur du nom : 8
Longueur manuelle du nom : 8

Concepts importants d'initialisation de chaînes :

• Le terminateur nul est crucial pour les opérations sur les chaînes
• Assurez-vous toujours d'avoir assez d'espace pour le terminateur nul
• Soyez prudent avec les tailles des tampons de chaîne pour éviter les dépassements de capacité

Utiliser les méthodes de la classe string (length, substr, find)

Dans cette étape, vous apprendrez à utiliser les puissantes méthodes de la classe string en C++, qui facilitent et rendent plus intuitive la manipulation des chaînes de caractères. Nous allons explorer des méthodes clés telles que length(), substr() et find().

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

touch ~/project/string_methods.cpp

Ajoutez le code suivant au fichier string_methods.cpp :

#include <iostream>
#include <string>

int main() {
    // Créer une chaîne de caractères
    std::string message = "Hello, C++ Programming!";

    // Utilisation de la méthode length()
    std::cout << "Longueur de la chaîne : " << message.length() << std::endl;

    // Utilisation de la méthode substr()
    std::cout << "Les 5 premiers caractères : " << message.substr(0, 5) << std::endl;
    std::cout << "Sous-chaîne à partir de l'index 7 : " << message.substr(7) << std::endl;

    // Utilisation de la méthode find()
    std::string search_word = "Programming";
    size_t position = message.find(search_word);

    if (position!= std::string::npos) {
        std::cout << "'" << search_word << "' trouvé à l'index : " << position << std::endl;
    } else {
        std::cout << "Mot non trouvé" << std::endl;
    }

    // Exemple supplémentaire de find()
    std::string email = "user@example.com";
    size_t at_symbol = email.find('@');
    size_t dot_symbol = email.find('.');

    std::cout << "Nom d'utilisateur : " << email.substr(0, at_symbol) << std::endl;
    std::cout << "Domaine : " << email.substr(at_symbol + 1, dot_symbol - at_symbol - 1) << std::endl;

    return 0;
}

Points clés sur les méthodes de la classe string :

• length() : Renvoie le nombre de caractères dans la chaîne
• substr() : Extrait une partie de la chaîne
  • Le premier argument est l'index de départ
  • Le deuxième argument (optionnel) est la longueur de la sous-chaîne
• find() : Recherche une sous-chaîne ou un caractère
  • Renvoie l'index de la première occurrence
  • Renvoie std::string::npos si non trouvé

Compilez et exécutez le programme :

g++ string_methods.cpp -o string_methods
./string_methods

Exemple de sortie :

Longueur de la chaîne : 23
Les 5 premiers caractères : Hello
Sous-chaîne à partir de l'index 7 : C++ Programming!
'Programming' trouvé à l'index : 11
Nom d'utilisateur : user
Domaine : example

Concepts importants sur les méthodes de chaîne :

• Les méthodes de chaîne offrent une manipulation de texte puissante
• L'indexation commence à 0
• Vérifiez toujours les valeurs de retour pour gérer les erreurs potentielles

Convertir entre les chaînes au style C et la classe string

Dans cette étape, vous apprendrez à convertir entre les chaînes de caractères au style C (C-style strings) et la classe string de C++. Ces conversions sont essentielles lorsque vous travaillez avec différentes représentations de chaînes en C++.

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

touch ~/project/string_conversion.cpp

Ajoutez le code suivant au fichier string_conversion.cpp :

#include <iostream>
#include <string>
#include <cstring>

int main() {
    // Conversion d'une chaîne au style C en chaîne C++
    const char* c_style_str = "Hello, C++ World!";
    std::string cpp_string(c_style_str);
    std::cout << "Chaîne C++ : " << cpp_string << std::endl;

    // Conversion d'une chaîne C++ en chaîne au style C
    std::string message = "Converting strings";
    const char* c_str = message.c_str();
    std::cout << "Chaîne au style C : " << c_str << std::endl;

    // Conversion manuelle en utilisant strcpy
    char buffer[50];
    strcpy(buffer, message.c_str());
    std::cout << "Copié dans le tampon : " << buffer << std::endl;

    // Comparaison de la longueur des chaînes
    std::cout << "Longueur de la chaîne C++ : " << message.length() << std::endl;
    std::cout << "Longueur de la chaîne au style C : " << strlen(c_str) << std::endl;

    return 0;
}

Méthodes clés de conversion :

• std::string(c_style_str) : Convertir une chaîne au style C en chaîne C++
• .c_str() : Convertir une chaîne C++ en chaîne au style C
• strcpy() : Copier manuellement une chaîne dans un tableau de caractères

Compilez et exécutez le programme :

g++ string_conversion.cpp -o string_conversion
./string_conversion

Exemple de sortie :

Chaîne C++ : Hello, C++ World!
Chaîne au style C : Converting strings
Copié dans le tampon : Converting strings
Longueur de la chaîne C++ : 18
Longueur de la chaîne au style C : 18

Concepts importants de conversion :

• Utilisez .c_str() pour obtenir un const char* à partir d'une chaîne C++
• Soyez prudent avec les tailles des tampons lors de la conversion
• strlen() fonctionne avec les chaînes au style C
• .length() fonctionne avec les chaînes C++

Trier les éléments d'un tableau en utilisant le tri à bulles

Dans cette étape, vous apprendrez à implémenter l'algorithme de tri à bulles (Bubble Sort) pour trier les éléments d'un tableau en C++. Le tri à bulles est une méthode de tri simple qui parcourt répétitivement la liste, compare les éléments adjacents et les échange s'ils ne sont pas dans le bon ordre.

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

touch ~/project/bubble_sort.cpp

Ajoutez le code suivant au fichier bubble_sort.cpp :

#include <iostream>

int main() {
    // Initialiser un tableau non trié
    int numbers[5] = {64, 34, 25, 12, 22};
    int size = 5;

    // Afficher le tableau original
    std::cout << "Tableau original : ";
    for (int i = 0; i < size; i++) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    // Implémentation du tri à bulles
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            // Comparer les éléments adjacents
            if (numbers[j] > numbers[j + 1]) {
                // Échanger les éléments
                int temp = numbers[j];
                numbers[j] = numbers[j + 1];
                numbers[j + 1] = temp;
            }
        }
    }

    // Afficher le tableau trié
    std::cout << "Tableau trié : ";
    for (int i = 0; i < size; i++) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

Concepts clés du tri à bulles :

• Compare les éléments adjacents
• Échange les éléments s'ils ne sont pas dans le bon ordre
• Répète les passages à travers le tableau jusqu'à ce qu'il soit trié
• Complexité temporelle : O(n²)

Compilez et exécutez le programme :

g++ bubble_sort.cpp -o bubble_sort
./bubble_sort

Exemple de sortie :

Tableau original : 64 34 25 12 22
Tableau trié : 12 22 25 34 64

Remarques importantes sur le tri :

• Le tri à bulles est simple mais inefficace pour les grands tableaux
• Il est utile à des fins éducatives
• Il existe des algorithmes de tri plus efficaces pour les applications réelles

Implémenter la recherche linéaire dans des tableaux

Dans cette étape, vous apprendrez à implémenter un algorithme de recherche linéaire en C++. La recherche linéaire est une méthode simple pour trouver un élément dans un tableau en vérifiant chaque élément séquentiellement jusqu'à ce que l'élément cible soit trouvé ou que la fin du tableau soit atteinte.

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

touch ~/project/linear_search.cpp

Ajoutez le code suivant au fichier linear_search.cpp :

#include <iostream>

int linearSearch(int arr[], int size, int target) {
    // Parcourir chaque élément du tableau
    for (int i = 0; i < size; i++) {
        // Vérifier si l'élément actuel correspond à la cible
        if (arr[i] == target) {
            return i;  // Retourner l'index si trouvé
        }
    }
    return -1;  // Retourner -1 si la cible n'est pas trouvée
}

int main() {
    // Créer un tableau de notes d'étudiants
    int scores[] = {85, 92, 78, 95, 88, 76, 90};
    int size = sizeof(scores) / sizeof(scores[0]);

    // Note cible à rechercher
    int targetScore = 78;

    // Effectuer la recherche linéaire
    int result = linearSearch(scores, size, targetScore);

    // Afficher les résultats de la recherche
    if (result!= -1) {
        std::cout << "Note cible " << targetScore
                  << " trouvée à l'index " << result << std::endl;
    } else {
        std::cout << "Note cible " << targetScore
                  << " non trouvée dans le tableau" << std::endl;
    }

    // Essayer une autre recherche
    int missingScore = 100;
    result = linearSearch(scores, size, missingScore);

    if (result!= -1) {
        std::cout << "Note " << missingScore
                  << " trouvée à l'index " << result << std::endl;
    } else {
        std::cout << "Note " << missingScore
                  << " non trouvée dans le tableau" << std::endl;
    }

    return 0;
}

Concepts clés de la recherche linéaire :

• Vérifie chaque élément du tableau séquentiellement
• Retourne l'index de l'élément cible si trouvé
• Retourne -1 si l'élément cible n'est pas dans le tableau
• Complexité temporelle : O(n) - temps linéaire
• Simple et fonctionne pour les tableaux non triés

Compilez et exécutez le programme :

g++ linear_search.cpp -o linear_search
./linear_search

Exemple de sortie :

Note cible 78 trouvée à l'index 2
Note 100 non trouvée dans le tableau

Remarques importantes sur la recherche :

• La recherche linéaire est simple mais inefficace pour les grands tableaux
• Adaptée pour les petits tableaux ou les collections non triées
• Il existe des algorithmes de recherche plus efficaces pour les tableaux triés

Gérer les entrées de chaînes de caractères avec getline()

Dans cette étape, vous apprendrez à utiliser getline() pour lire des lignes complètes de texte en entrée en C++. Contrairement à cin >>, getline() peut lire des chaînes contenant des espaces et gérer des scénarios d'entrée plus complexes.

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

touch ~/project/getline_input.cpp

Ajoutez le code suivant au fichier getline_input.cpp :

#include <iostream>
#include <string>

int main() {
    // Déclarer une chaîne pour stocker l'entrée
    std::string fullName;
    std::string address;

    // Demander le nom complet en entrée
    std::cout << "Entrez votre nom complet : ";
    std::getline(std::cin, fullName);

    // Demander l'adresse en entrée
    std::cout << "Entrez votre adresse complète : ";
    std::getline(std::cin, address);

    // Afficher l'entrée avec des informations supplémentaires
    std::cout << "\n--- Informations utilisateur ---" << std::endl;
    std::cout << "Nom : " << fullName << std::endl;
    std::cout << "Adresse : " << address << std::endl;

    // Montrer la lecture de plusieurs lignes
    std::string multiLineText;
    std::cout << "\nEntrez une description multi-lignes (appuyez sur Ctrl+D pour terminer) :" << std::endl;

    std::string line;
    while (std::getline(std::cin, line)) {
        multiLineText += line + "\n";
    }

    std::cout << "\nVotre description :" << std::endl;
    std::cout << multiLineText;

    return 0;
}

Concepts clés de getline() :

• Lit une ligne entière de texte, y compris les espaces
• Syntaxe : std::getline(flux_d_entree, variable_de_chaîne)
• Peut lire plusieurs lignes d'entrée
• Gère les entrées complexes contenant des espaces
• Utile pour lire des noms complets, des adresses, etc.

Compilez le programme :

g++ getline_input.cpp -o getline_input
./getline_input

Exemple d'interaction :

Entrez votre nom complet : John Michael Smith
Entrez votre adresse complète : 123 Main Street, Anytown, USA

--- Informations utilisateur ---
Nom : John Michael Smith
Adresse : 123 Main Street, Anytown, USA

Entrez une description multi-lignes (appuyez sur Ctrl+D pour terminer) :
This is a sample
multi-line description
with several lines of text.

Votre description :
This is a sample
multi-line description
with several lines of text.

Remarques importantes sur la gestion des entrées :

• getline() lit jusqu'au caractère de fin de ligne
• Utile pour capturer des entrées de texte complètes
• Peut être combiné avec d'autres méthodes d'entrée

Résumé

Dans ce laboratoire, vous apprendrez à créer et initialiser des tableaux unidimensionnels en C++, à accéder et modifier les éléments d'un tableau à l'aide d'un index, à implémenter des tableaux bidimensionnels pour représenter des matrices, à initialiser des chaînes de caractères au style C (C-style strings) avec un terminateur nul, à utiliser les méthodes de la classe string, à convertir entre les chaînes au style C et la classe string, à trier les éléments d'un tableau en utilisant le tri à bulles (bubble sort), à implémenter la recherche linéaire dans des tableaux et à gérer les entrées de chaînes de caractères avec getline().

Vous explorerez différentes façons d'initialiser des tableaux, notamment en spécifiant la taille et en initialisant tous les éléments, en laissant le compilateur déterminer la taille, en initialisant tous les éléments à zéro et en assignant manuellement des valeurs à l'aide d'un index. Vous apprendrez également à accéder et modifier les éléments d'un tableau à l'aide d'un index et à gérer les limites des tableaux pour éviter les erreurs. De plus, vous travaillerez avec des tableaux bidimensionnels, des chaînes de caractères au style C et la classe string, en apprenant à convertir entre elles et à effectuer diverses opérations.