Structures de contrôle

			{
				Instruction1 ;
				Instruction2 ;
				Instruction3 ;
			} 
			

• Dans une première étape on fait des séquencements d'instructions élémentaires telles que les affectations et les ordres de lecture et d'écriture. Mais on peut, bien sûr, faire des séquencements de toutes sortes d'instructions.
• Les accolades sont des marqueurs qui sont indispensables lorsqu'un séquencement sera placé dans certaines instructions ci­dessous. Mais ceci n'est pas toujours le cas, en particulier si le corps du programme ne comprend qu'une instruction. Il est alors inutile d'indiquer explicitement le séquencement, en particulier la structure :
  

  {{ ... }} 

  
  serait ridicule.

			{ 
				Instruction1 ;
				Instruction2 ;
				Instruction3 ; 
				; 
			} 
			

• ! P
• P && Q
• P || Q

• == pour la relation d'égalité,
• != pour la relation de diséquation,
• < pour strictement plus petit,
• <= pour plus petit ou égal,
• > pour strictement plus grand,
• >= pour plus grand ou égal.

				X*X - 5*X + 6 <= 0
			

				(2 <= X) && (X <= 3)
			

			while (condition)
				instruction 
			

while (condition)

• Rappelons que nous avons déjà vu plusieurs instructions, mais que nous n'avons pas donné de définition générale de ce qu'est une instruction. Nous continuerons pour l'instant à en parler au sens intuitif.
• Lorsque instruction est une instruction complexe de séquencement, il est important de la commencer par

  {

  et de la terminer par

  }

  .

				#include <stdio.h> 
				#include <math.h> 
				
				int main(void) 
				{ 
					float x, y; 
					
					printf("x = "); /* prompteur pour x */
					scanf("%f",&X); /* nouveau lecteur pour x */
					
					while (x != 1000.0) /* boucle tant que "x différent de 1000.0" */
					{
						y = (sin(x) + log(x))/(exp(x) + 2); /* calcul */
						printf("f(%f) = %f", x, y);
						printf("\n"); /* Passage à la ligne esthétique */
						
						printf("x = "); /* nouveau prompteur pour x */
						scanf("%f",&X); /* nouveau lecteur pour x */
					}
				}
			

• Remarquons l'obligation d'écrire deux fois les instructions permettant l'entrée des données. La premiére, précédant l'écriture de la boucle, s'appelle l'initialisation de la boucle.
• La valeur 1000 est ce qu'on appelle une valeur signal ou sentinelle.
• Une variable telle que x dont la valeur conditionne l'exécution des instructions du corps de la boucle, donc contrôle le déroulement d'une structure répétitive, s'appelle variable de boucle ou variable de contrôle de boucle.

			do
				instruction
			while (condition) ; 

				#include <stdio.h> 
				#include <math.h>
				
				int main(void)
				{
					float x, y; 
					
					printf("x = ");
					scanf("%f",&X);
				
					do 
					{
						y = (sin(x) + log(x))/(exp(x) + 2);
						printf("f(%f) = %f \n", x, y);
						
						printf("x = ");
						scanf("%f",&X);
					} while (x != 1000.0);
				}
			

			for (Initialisation ; Condition ; Réinitialisation )
				instruction 

• Initialisation est une instruction initialisant la (ou les) variable(s) de contrôle ;
• Condition est une expression booléenne, appelée condition de bouclage ;
• Réinitialisation est une expression permettant de réinitialiser la (ou les) variable(s) de contrôle

			for (i = 1; i <= 100; i = i+1) 
				sum = sum + i; 
			

				#include <stdio.h> 
				#include <math.h> 
					
				int main(void) 
				{ 
					float x, y; 
					int i; 
				
					for (i=1 ; i <= 10 ; i = i+1) /* pour i allant de 1 à 10, de 1 en 1 */
					{ 
						printf("x = "); 
						scanf("%f",&X); 
						
						y = (sin(x) + log(x))/(exp(x) + 2);
						printf("f(%f) = %f \n", x, y);
					}
				} 
					

				#include <stdio.h>
				
				int main(void)
				{ 
					int i, N, S=0; /* seule la variable S est inititalisée */
					
					printf("N = "); 
					scanf("%d",&N); 
					
					for (i = 1; i <= N; i = i + 1) 
						S = S + i*i*i*i*i; /* on ajout a S son ancienne valeur puis 'i'^5 */
					
					printf("S = %d.", S); /* une fois sorti de la boucle, on affiche la somme */
				}