Aller au contenu

Programmation C source/tests

Un livre de Wikilivres.
Programmation C source
Programmation C++
Programmation C++
Sommaire
Modifier ce modèle
#include <stdio.h>

int main(int argc, char * argv[])
{
	printf("------------------------------\n");
	printf(" Test if\n");
	printf("------------------------------\n");

	#if 0
	 if (condition)
		instructions
	 else
		autre instructions
	#endif

	/* Si la condition est vérifiée, alors on exécute le bloc d'instructions, sinon on
	   exécute l'autre bloc. La clause else est facultative, qui plus est une clause else
	   se réfère toujours à la dernière instruction if rencontrée. */

	/* Ce code est volontairement indenté de manière ambiguë */
	#if 0
	 if (condition)
		if (autre_condition) /* ... */ ;
	 else
		/* ... */ ;
	#endif
	/* Dans ce dernier exemple la clause else se rapportait bien-sûr au second if selon
	   la règle énoncée ci-dessus. */

	#if 0
	 if (condition)
	 {
		if (autre_condition) /* ... */ ;
	 }
	 else /* ... */ ;
	#endif
	/* Dans cet exemple la clause else se rapporte au premier if. */

	/* lorsqu'un if contient une instruction (for, do, while, switch, goto, return, etc.)
	   il est conseillé de la mettre entre accolades. */

	printf("\n------------------------------\n");
	printf(" Test switch\n");
	printf("------------------------------\n");

	/* Cette instruction permet de tester si une expression coïncide avec un certain
	   nombre de constantes, et d'exécuter une action par défaut dans le cas où aucune
	   valeur ne correspond à celle de l'expression. Cela permet un traitement beaucoup
	   plus efficace et lisible qu'une succession de if/else imbriqués. Insistons sur le
	   terme constante : il est en effet impossible d'utiliser des expressions dont la
	   valeur n'est pas connue à la compilation (c'est à dire de variable dans les
	   instructions case). */

	#if 0
	 switch (expression)
	 {
		case valeur1:
			bloc1
		case valeur2:
			bloc2
		/*...*/
		case valeurN:
			blocN
		default:
			blocD
	 }
	#endif

	/* Compare la valeur de l'expression à celles de valeur1, valeur2, ..., valeurN. En
	   cas d'égalité entre expression et valeurI les blocs sont exécutés séquentiellement
	   à partir de blocI, et ce jusqu'à la fin de l'instruction switch. Si expression est
	   égale à valeur2, dans cet exemple, les blocs bloc2 à blocN et même blocD seront
	   exécutés. Pour empécher ce comportement on utilise l'instruction break, que l'on
	   peut placer à n'importe quel endroit pour sortir (aller à la fin) de l'instruction
	   switch. En général, on retrouve plus fréquemment l'instruction switch écrite de la
	   sorte : */

	#if 0
	 switch (expression)
	 {
		case valeur1:
			bloc1
			break;
		case valeur2:
			bloc2
			break;
		/*...*/
		case valeurN:
			blocN
		/* pas de break; */
		default:
			blocD
	 }
	#endif

	/* C'est en fait tellement rare de ne pas mettre de break entre les différents cas,
	   qu'il est conseillé de mettre un commentaire pour les cas où cette instruction est
	   délibérément omise, ça permet de bien signaler au lecteur qu'il ne s'agit pas d'un
	   oubli. */

	printf("\n------------------------------\n");
	printf(" Expression conditionnelle\n");
	printf("------------------------------\n");

	#if 0
	 test ? expression_si_vrai : expression_si_faux
	#endif

	printf("%s\n", argc < 2 ? "Vous n'avez pas donné d'argument." : "Vous avez donné au moins un argument.");

	/* On teste si le nombre d'arguments passé à main est inférieur à 2 avec
	   l'expression argc < 2 et on renvoie "vous n'avez pas donné d'argument" si
	   l'expression est vraie et "vous avez donné au moins un argument" sinon. Le
	   résultat de l'évaluation est alors passé à la fonction printf qui affiche le
	   résultat. */

	return 0;
}