Introduction
Dans ce laboratoire, vous apprendrez à manipuler les éléments de tableau en programmation C. Le laboratoire couvre les compétences fondamentales de déclaration et d'initialisation de tableaux, d'accès et de modification des éléments de tableau, d'itération à travers les tableaux, de réalisation de calculs sur les tableaux et d'allocation dynamique de mémoire pour les tableaux. Vous explorerez diverses techniques pour travailler avec les tableaux, notamment la déclaration et l'initialisation de tableaux avec des valeurs spécifiques, l'initialisation partielle de tableaux et l'affectation dynamique de valeurs aux éléments de tableau. À la fin du laboratoire, vous aurez une solide compréhension de la manière d'administrer et de manipuler efficacement les structures de données de tableau en C.
Déclarer et initialiser un tableau
Dans cette étape, vous apprendrez à déclarer et initialiser des tableaux en programmation 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ë.
Commençons par créer un nouveau fichier C pour explorer la déclaration et l'initialisation de tableaux :
cd ~/project
touch array_basics.c
Maintenant, écrivons un programme qui montre différentes façons de déclarer et initialiser des tableaux :
#include <stdio.h>
int main() {
// Méthode 1 : Déclarer et initialiser un tableau avec des valeurs spécifiques
int numbers[5] = {10, 20, 30, 40, 50};
// Méthode 2 : Déclarer un tableau et l'initialiser plus tard
int scores[3];
scores[0] = 85;
scores[1] = 92;
scores[2] = 78;
// Méthode 3 : Initialiser partiellement un tableau (les éléments restants sont mis à 0)
int grades[4] = {100, 95};
// Afficher les tableaux pour vérifier l'initialisation
printf("Numbers array: ");
for (int i = 0; i < 5; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
printf("Scores array: ");
for (int i = 0; i < 3; i++) {
printf("%d ", scores[i]);
}
printf("\n");
printf("Grades array: ");
for (int i = 0; i < 4; i++) {
printf("%d ", grades[i]);
}
printf("\n");
return 0;
}
Compilez et exécutez le programme :
gcc array_basics.c -o array_basics
./array_basics
Exemple de sortie :
Numbers array: 10 20 30 40 50
Scores array: 85 92 78
Grades array: 100 95 0 0
Analysons les méthodes d'initialisation de tableau :
int numbers[5] = {10, 20, 30, 40, 50};- Déclare un tableau d'entiers avec 5 éléments
- Initialise tous les éléments avec des valeurs spécifiques
- La taille est déterminée par le nombre d'éléments dans la liste d'initialisation
int scores[3];suivi d'une affectation d'éléments individuels- Déclare un tableau d'abord
- Assigne des valeurs aux éléments individuels plus tard
- Utile lorsque vous voulez définir des valeurs de manière dynamique
int grades[4] = {100, 95};- Initialise partiellement un tableau
- Les éléments non spécifiés sont automatiquement mis à 0
- Permet d'économiser du temps lorsque vous ne voulez définir que quelques valeurs initiales
Points clés à retenir :
- Les indices de tableau commencent à 0
- Vous devez spécifier le type d'éléments que le tableau stockera
- Les tableaux ont une taille fixe une fois déclarés
- Assurez-vous toujours de ne pas accéder aux éléments de tableau au-delà de leur taille déclarée
Accéder et modifier les éléments d'un tableau
Dans cette étape, vous apprendrez à accéder et modifier les éléments individuels d'un tableau en programmation C. En vous appuyant sur l'étape précédente, nous explorerons comment interagir avec les éléments de tableau en utilisant l'indexation et montrerons diverses façons de manipuler le contenu des tableaux.
Créons un nouveau fichier C pour pratiquer l'accès et la modification des éléments de tableau :
cd ~/project
touch array_access.c
Maintenant, écrivons un programme qui montre l'accès et la modification des éléments de tableau :
#include <stdio.h>
int main() {
// Déclarer et initialiser un tableau
int temperatures[5] = {72, 68, 75, 80, 65};
// Accéder aux éléments individuels du tableau
printf("First temperature: %d\n", temperatures[0]);
printf("Third temperature: %d\n", temperatures[2]);
// Modifier les éléments du tableau
temperatures[1] = 70; // Changer le deuxième élément
temperatures[4] = 73; // Changer le dernier élément
// Afficher le tableau modifié
printf("Modified temperatures: ");
for (int i = 0; i < 5; i++) {
printf("%d ", temperatures[i]);
}
printf("\n");
// Montrer le calcul sur les éléments de tableau
int average = (temperatures[0] + temperatures[1] + temperatures[2] +
temperatures[3] + temperatures[4]) / 5;
printf("Average temperature: %d\n", average);
return 0;
}
Compilez et exécutez le programme :
gcc array_access.c -o array_access
./array_access
Exemple de sortie :
First temperature: 72
Third temperature: 75
Modified temperatures: 72 70 75 80 73
Average temperature: 74
Analysons les concepts clés :
Indexation de tableau
- Les tableaux sont accessibles à l'aide d'une indexation basée sur zéro
temperatures[0]fait référence au premier élémenttemperatures[4]fait référence au dernier élément dans un tableau de 5 éléments
Modification des éléments de tableau
- Les éléments individuels peuvent être modifiés directement en utilisant leur index
temperatures[1] = 70;remplace le deuxième élément par 70- Vous pouvez modifier les éléments à n'importe quel index valide
Calculs sur les éléments de tableau
- Vous pouvez effectuer des calculs en utilisant les éléments individuels de tableau
- Dans l'exemple, nous avons calculé la température moyenne
- Accédez aux éléments directement par leur index dans les opérations mathématiques
Pièges courants à éviter :
- N'accédez jamais à un index de tableau en dehors de ses limites
- Les indices de tableau commencent à 0, pas à 1
- Faites attention à ne pas dépasser la taille déclarée du tableau
Itérer à travers un tableau
Dans cette étape, vous apprendrez différentes méthodes pour itérer à travers des tableaux en programmation C. L'itération est cruciale pour traiter efficacement les éléments de tableau et effectuer diverses opérations sur le contenu des tableaux.
Créons un nouveau fichier C pour explorer les techniques d'itération sur les tableaux :
cd ~/project
touch array_iteration.c
Maintenant, écrivons un programme qui montre plusieurs façons d'itérer à travers un tableau :
#include <stdio.h>
int main() {
// Déclarer et initialiser un tableau de notes d'étudiants
int scores[6] = {85, 92, 78, 90, 88, 95};
int total = 0;
// Méthode 1 : Utilisation d'une boucle for standard
printf("Method 1 - Standard For Loop:\n");
for (int i = 0; i < 6; i++) {
printf("Score %d: %d\n", i + 1, scores[i]);
total += scores[i];
}
// Calculer et afficher la moyenne
float average = (float)total / 6;
printf("\nTotal Score: %d\n", total);
printf("Average Score: %.2f\n", average);
// Méthode 2 : Itération inverse
printf("\nMethod 2 - Reverse Iteration:\n");
printf("Scores in reverse order:\n");
for (int i = 5; i >= 0; i--) {
printf("Score %d: %d\n", i + 1, scores[i]);
}
// Méthode 3 : Itération avec une boucle while
printf("\nMethod 3 - While Loop Iteration:\n");
int j = 0;
while (j < 6) {
if (scores[j] >= 90) {
printf("High score detected: %d\n", scores[j]);
}
j++;
}
return 0;
}
Compilez et exécutez le programme :
gcc array_iteration.c -o array_iteration
./array_iteration
Exemple de sortie :
Method 1 - Standard For Loop:
Score 1: 85
Score 2: 92
Score 3: 78
Score 4: 90
Score 5: 88
Score 6: 95
Total Score: 528
Average Score: 88.00
Method 2 - Reverse Iteration:
Scores in reverse order:
Score 6: 95
Score 5: 88
Score 4: 90
Score 3: 78
Score 2: 92
Score 1: 85
Method 3 - While Loop Iteration:
High score detected: 92
High score detected: 90
High score detected: 95
Techniques d'itération clés :
Boucle for standard
- Méthode la plus courante pour l'itération sur les tableaux
- Permet un contrôle précis de l'index
- Idéale pour le traitement en avant
Itération inverse
- Itérer du dernier élément au premier
- Utile pour des exigences de traitement spécifiques
- Utilise un compteur de boucle décroissant
Itération avec une boucle while
- Fournit un contrôle flexible de l'itération
- Peut inclure un traitement conditionnel
- Utile pour une logique d'itération complexe
Principes d'itération importants :
- Définissez toujours clairement les limites de la boucle
- Utilisez la longueur du tableau pour éviter les accès hors limites
- Choisissez la méthode d'itération la plus appropriée pour votre tâche spécifique
Effectuer des calculs sur un tableau
Dans cette étape, vous apprendrez à effectuer diverses calculs sur des tableaux en programmation C. Nous explorerons des techniques pour trouver les valeurs maximales et minimales, calculer les sommes, les moyennes et appliquer des transformations mathématiques aux éléments de tableau.
Créons un nouveau fichier C pour pratiquer les calculs sur les tableaux :
cd ~/project
touch array_calculations.c
Maintenant, écrivons un programme qui montre différentes techniques de calcul sur les tableaux :
#include <stdio.h>
#include <limits.h>
int main() {
// Déclarer et initialiser un tableau de données de ventes
int sales[7] = {1200, 1500, 980, 1750, 1100, 1300, 1600};
// Calculer le total des ventes
int total_sales = 0;
for (int i = 0; i < 7; i++) {
total_sales += sales[i];
}
printf("Total Weekly Sales: $%d\n", total_sales);
// Calculer les ventes moyennes
float average_sales = (float)total_sales / 7;
printf("Average Daily Sales: $%.2f\n", average_sales);
// Trouver les ventes maximales
int max_sales = sales[0]; // Commencer avec le premier élément
for (int i = 1; i < 7; i++) {
if (sales[i] > max_sales) {
max_sales = sales[i];
}
}
printf("Highest Daily Sales: $%d\n", max_sales);
// Trouver les ventes minimales
int min_sales = sales[0]; // Commencer avec le premier élément
for (int i = 1; i < 7; i++) {
if (sales[i] < min_sales) {
min_sales = sales[i];
}
}
printf("Lowest Daily Sales: $%d\n", min_sales);
// Appliquer une augmentation en pourcentage
float increase_percentage = 1.1; // Augmentation de 10%
printf("\nSales After 10%% Increase:\n");
for (int i = 0; i < 7; i++) {
float increased_sale = sales[i] * increase_percentage;
printf("Day %d: $%.2f\n", i + 1, increased_sale);
}
return 0;
}
Compilez et exécutez le programme :
gcc array_calculations.c -o array_calculations
./array_calculations
Exemple de sortie :
Total Weekly Sales: $9430
Average Daily Sales: $1347.14
Highest Daily Sales: $1750
Lowest Daily Sales: $980
Sales After 10% Increase:
Day 1: $1320.00
Day 2: $1650.00
Day 3: $1078.00
Day 4: $1925.00
Day 5: $1210.00
Day 6: $1430.00
Day 7: $1760.00
Techniques clés de calcul sur les tableaux :
Calcul du total
- Utilisez une boucle pour sommer tous les éléments du tableau
- Accumulez les valeurs dans une variable séparée
- Utile pour trouver la somme totale
Calcul de la moyenne
- Divisez la somme totale par le nombre d'éléments
- Utilisez le transtypage pour une précision en virgule flottante
- Fournit la valeur moyenne des éléments du tableau
Recherche du maximum/minimum
- Initialisez avec le premier élément du tableau
- Comparez chaque élément suivant
- Mettez à jour la valeur max/min lorsqu'un nouvel extrême est trouvé
Transformations élément par élément
- Appliquez des opérations mathématiques à chaque élément
- Peut modifier les valeurs du tableau en fonction de règles spécifiques
- Utile pour la mise à l'échelle, l'ajustement ou la transformation des données
Principes de calcul importants :
- Tenez toujours compte des limites du tableau
- Utilisez les types de données appropriés
- Faites attention à la division entière
- Initialisez les variables accumulateurs avant les calculs
Allouer dynamiquement la mémoire d'un tableau
Dans cette étape, vous apprendrez à allouer dynamiquement de la mémoire pour des tableaux en programmation C en utilisant les fonctions malloc(), realloc() et free(). L'allocation dynamique de mémoire vous permet de créer des tableaux dont les tailles sont déterminées à l'exécution.
Créons un nouveau fichier C pour explorer l'allocation dynamique de mémoire :
cd ~/project
touch dynamic_array.c
Maintenant, écrivons un programme qui montre l'allocation dynamique de mémoire pour un tableau :
#include <stdio.h>
#include <stdlib.h>
int main() {
// Allocation dynamique de mémoire pour un tableau d'entiers
int array_size;
printf("Enter the number of elements: ");
scanf("%d", &array_size);
// Allouer de la mémoire dynamiquement
int *dynamic_array = (int *)malloc(array_size * sizeof(int));
// Vérifier si l'allocation de mémoire a réussi
if (dynamic_array == NULL) {
printf("Memory allocation failed!\n");
return 1;
}
// Saisir les éléments du tableau
printf("Enter %d integers:\n", array_size);
for (int i = 0; i < array_size; i++) {
printf("Element %d: ", i + 1);
scanf("%d", &dynamic_array[i]);
}
// Afficher les éléments du tableau
printf("\nArray elements:\n");
for (int i = 0; i < array_size; i++) {
printf("%d ", dynamic_array[i]);
}
printf("\n");
// Redimensionner dynamiquement le tableau
int new_size;
printf("\nEnter new array size: ");
scanf("%d", &new_size);
// Réallouer de la mémoire
int *resized_array = (int *)realloc(dynamic_array, new_size * sizeof(int));
// Vérifier si la réallocation a réussi
if (resized_array == NULL) {
printf("Memory reallocation failed!\n");
free(dynamic_array);
return 1;
}
dynamic_array = resized_array;
// Si la nouvelle taille est plus grande, initialiser les nouveaux éléments
if (new_size > array_size) {
for (int i = array_size; i < new_size; i++) {
dynamic_array[i] = 0;
}
}
// Afficher le tableau redimensionné
printf("Resized array:\n");
for (int i = 0; i < new_size; i++) {
printf("%d ", dynamic_array[i]);
}
printf("\n");
// Libérer la mémoire allouée dynamiquement
free(dynamic_array);
return 0;
}
Compilez et exécutez le programme :
gcc dynamic_array.c -o dynamic_array
./dynamic_array
Exemple d'interaction :
Enter the number of elements: 3
Enter 3 integers:
Element 1: 10
Element 2: 20
Element 3: 30
Array elements:
10 20 30
Enter new array size: 5
Resized array:
10 20 30 0 0
Concepts clés d'allocation dynamique de mémoire :
Fonction
malloc()- Alloue la mémoire demandée et retourne un pointeur
- Syntaxe :
pointer = (type *)malloc(size * sizeof(type)) - Vérifiez toujours si le pointeur est NULL pour vous assurer que l'allocation a réussi
Fonction
realloc()- Redimensionne un bloc de mémoire précédemment alloué
- Peut augmenter ou diminuer la taille du tableau
- Conserve les données existantes lors de l'agrandissement
Fonction
free()- Désalloue la mémoire allouée dynamiquement
- Empêche les fuites de mémoire
- Doit être appelée pour chaque allocation
malloc()/realloc()
Principes importants d'allocation de mémoire :
- Vérifiez toujours si l'allocation a réussi
- Libérez la mémoire allouée dynamiquement lorsque vous n'en avez plus besoin
- Faites attention lors du redimensionnement des tableaux
- Gérez gracieusement les échecs potentiels d'allocation
Résumé
Dans ce laboratoire (lab), vous avez appris à déclarer et initialiser des tableaux en programmation C, à accéder et modifier les éléments de tableau, à itérer à travers des tableaux, à effectuer des calculs sur des tableaux et à allouer dynamiquement de la mémoire pour des tableaux. Vous avez exploré différentes méthodes pour déclarer et initialiser des tableaux, notamment en spécifiant directement les valeurs, en assignant des valeurs ultérieurement et en initialisant partiellement des tableaux. Vous avez également appris à afficher le contenu des tableaux pour vérifier leur initialisation. Ces opérations de base sur les tableaux sont essentielles pour travailler avec des structures de données en C et constituent les éléments de base pour des manipulations de tableaux plus complexes.
