Instruction sur la déclaration continue en C : Un guide amical pour les débutants

Salut à toi, futurs programmeurs ! Aujourd'hui, nous allons plonger dans l'une des déclarations de contrôle de flux les plus utiles en programmation C : la déclaration continue. Ne t'inquiète pas si tu es nouveau dans ce domaine ; nous allons commencer par les bases et progresser pas à pas. À la fin de ce tutoriel, tu seras un pro dans l'utilisation des déclarations continue !

Qu'est-ce que la déclaration continue en C ?

Imaginons que tu es dans une file d'attente pour un buffet, en choisissant tes aliments préférés. Soudain, tu vois un plat que tu n'aimes pas. Que fais-tu ? Tu le sautes et tu passes au suivant, n'est-ce pas ? Eh bien, c'est exactement ce que fait la déclaration continue en programmation !

La déclaration continue nous permet de sauter le reste de l'itération actuelle d'une boucle et de passer à l'itération suivante. C'est comme dire : "Non, je ne suis pas intéressé par celui-ci. Passons au suivant !"

Pourquoi utiliser continue ?

1. Il nous aide à éviter des exécutions de code inutiles.
2. Il rend nos boucles plus efficaces.
3. Il peut simplifier des logiques conditionnelles complexes.

Maintenant, voyons comment nous écrivons cette déclaration magique !

Syntaxe de la déclaration continue

La syntaxe de la déclaration continue est magnifique par sa simplicité :

continue;

C'est tout ! Juste un mot suivi d'un point-virgule. Mais ne te laisse pas tromper par sa simplicité - cette petite déclaration peut être incroyablement puissante lorsqu'elle est utilisée correctement.

Diagramme de flux de la déclaration continue

Pour mieux comprendre comment fonctionne la déclaration continue, visualisons-le avec un diagramme de flux :

┌─────────────┐
│ Début de la │
│ boucle      │
└──────┬──────┘
│
┌──────▼──────┐
│ Vérification │
│ de condition │
└──────┬──────┘
│
┌──────▼──────┐
│  Continue   │
│ rencontré   │
└──────┬──────┘
│
│    ┌─────────────────┐
└────► Sauter le reste │
│ de l'itération actuelle│
└─────────┬───────┘
│
┌─────────▼───────┐
│ Itération suivante │
└─────────────────┘

Comme vous pouvez le voir, lorsque la déclaration continue est rencontrée, elle saute immédiatement à l'itération suivante, en évitant tout le code qui suit dans l'itération actuelle.

Utilisation de continue avec des boucles imbriquées

Maintenant, parlons de quelque chose de plus avancé : utiliser continue avec des boucles imbriquées. Ne t'inquiète pas, ce n'est pas aussi effrayant qu'il n'y paraît !

Lorsque vous utilisez continue dans une boucle imbriquée, il n'affecte que la boucle la plus interne contenant la déclaration continue. C'est comme avoir un bouton "sauter" pour chaque attraction d'un parc d'attractions, plutôt que de sauter tout le parc !

Voyons un exemple :

#include <stdio.h>

int main() {
int i, j;

for (i = 1; i <= 3; i++) {
printf("Itération de la boucle externe %d:\n", i);

for (j = 1; j <= 5; j++) {
if (j == 3) {
continue;
}
printf("  Boucle interne : %d\n", j);
}
}

return 0;
}

Dans cet exemple, la déclaration continue est à l'intérieur de la boucle interne. Elle cause la boucle à sauter l'impression lorsque j est 3, mais elle n'affecte pas du tout la boucle externe.

Output :

Itération de la boucle externe 1:
Boucle interne : 1
Boucle interne : 2
Boucle interne : 4
Boucle interne : 5
Itération de la boucle externe 2:
Boucle interne : 1
Boucle interne : 2
Boucle interne : 4
Boucle interne : 5
Itération de la boucle externe 3:
Boucle interne : 1
Boucle interne : 2
Boucle interne : 4
Boucle interne : 5

Voyez comment le nombre 3 est manquant dans la sortie de la boucle interne ? C'est notre déclaration continue qui agit !

Exemples de la déclaration continue

Maintenant, regardons d'autres exemples pour bien comprendre l'utilisation de la déclaration continue.

Exemple 1 : Sauter les nombres pairs

#include <stdio.h>

int main() {
int i;

for (i = 1; i <= 10; i++) {
if (i % 2 == 0) {
continue;
}
printf("%d ", i);
}

return 0;
}

Output :

1 3 5 7 9

Dans cet exemple, nous utilisons la déclaration continue pour sauter les nombres pairs. Lorsque i est divisible par 2 (c'est-à-dire qu'il est pair), la déclaration continue cause la boucle à sauter l'impression du nombre.

Exemple 2 : Sauter les nombres négatifs dans les entrées utilisateur

#include <stdio.h>

int main() {
int num, sum = 0;

printf("Entrez des nombres (entrez 0 pour arrêter):\n");

while (1) {
scanf("%d", &num);

if (num == 0) {
break;
}

if (num < 0) {
printf("Les nombres négatifs ne sont pas autorisés. Essayez encore.\n");
continue;
}

sum += num;
}

printf("Somme des nombres positifs : %d\n", sum);

return 0;
}

Dans cet exemple, nous utilisons continue pour sauter les nombres négatifs dans les entrées utilisateur. Si l'utilisateur entre un nombre négatif, nous affichons un message et utilisons continue pour éviter d'ajouter ce nombre à la somme.

Exemple 3 : Traiter des éléments spécifiques dans un tableau

#include <stdio.h>

int main() {
int numbers[] = {1, -2, 3, -4, 5, -6, 7, -8, 9, -10};
int i, positiveSum = 0;

for (i = 0; i < 10; i++) {
if (numbers[i] < 0) {
continue;
}
positiveSum += numbers[i];
}

printf("Somme des nombres positifs : %d\n", positiveSum);

return 0;
}

Output :

Somme des nombres positifs : 25

Dans cet exemple final, nous utilisons continue pour sauter les nombres négatifs dans un tableau et sommer uniquement les nombres positifs.

Conclusion

Et voilà, les amis ! Nous avons traversé le monde des déclarations continue en C. De la compréhension de ce qu'elles sont et de la manière dont elles fonctionnent, à leur utilisation dans des boucles imbriquées et des exemples du monde réel, vous êtes maintenant équipés pour utiliser les déclarations continue comme un pro !

N'oubliez pas, la programmation, c'est tout về la pratique. Alors n'ayez pas peur d'expérimenter avec ces concepts dans votre propre code. Essayez de combiner continue avec différents types de boucles, ou utilisez-le pour résoudre des problèmes de manière unique.

Bonne programmation, et que le continue soit avec vous ! ?

Credits: Image by storyset