Les instructions de branchement inconditionnel :
break, continue et goto
1. L'instruction break
Le langage C autorise également l'emploi de l’instruction break dans une boucle. Dans ce cas,
elle sert à interrompre le déroulement de la boucle, en passant à l'instruction qui suit cette
boucle. L’ instruction break n'a d'intérêt que si son exécution est conditionnée par un choix ; dans
le cas contraire, elle serait exécutée dès le premier tour de la boucle, ce qui rendrait la boucle
inutile.
Passage de paramètres par variable ou par valeur à une
fonction
Il y a deux méthodes pour passer des variables en paramètre dans une fonction : le passage
par valeur et le passage par variable. Ces méthodes sont décrites ci-dessous.
Passage par valeur
La valeur de l’expression passée en paramètre est copiée dans une variable locale. C’est
cette variable qui est utilisée pour faire les calculs dans la fonction appelée.
Si l’expression passée en paramètre est une variable, son contenu est copié dans la variable
locale. Aucune modification de la variable locale dans la fonction appelée ne modifie la
variable passée en paramètre, parce que ces modifications ne s’appliquent qu’à une copie de
cette dernière.
Le langage C ne permet de faire que des passages par valeur.
Exemple : Passage de paramètre par valeur
void test(int j) /* j est la copie de la valeur passée en paramètre */
{
j=3; /* Modifie j, mais pas la variable fournie par l’appelant. */
return;
}
int main()
{
int i=2;
test(i); /* Le contenu de i est copié dans j. i n’est pas modifié. Il vaut toujours 2. */
test(2); /* La valeur 2 est copiée dans j. */
return 0;
}
Passage par variable
La deuxième technique consiste à passer non plus la valeur des variables comme paramètre, mais
à passer les variables elles-mêmes. Il n’y a donc plus de copie, plus de variable locale. Toute
modification du paramètre dans la fonction appelée entraîne la modification de la variable passée
en paramètre.
Le C ne permet pas de faire ce type de passage de paramètres (le C++ le permet en
revanche).
Avantages et Inconvénients des deux Méthodes de Passage de
paramètre
Les passages par variables sont plus rapides et plus économes en mémoire que les
passages par valeur, puisque les étapes de la création de la variable locale et la copie de la
valeur ne sont pas faites. Il faut donc éviter les passages par valeur dans les cas d’appels
récursifs de fonction ou de fonctions travaillant avec des grandes structures de données
(matrices par exemple).
Les passages par valeurs permettent d’éviter de détruire par mégarde les variables passées
en paramètre.
Comment passer les paramètres par variable en C ?
Il n’y a qu’une solution : passer l’adresse de la variable. Cela constitue donc une
application des pointeurs.
Exemple: Passage de paramètre par variable en C
void test(int *pj) /* test attend l’adresse d’un entier... */
{
*pj=2; /* ... pour le modifier. */
return;
}
int main()
{
int i=3;
test(&i); /* On passe l’adresse de i en paramètre. */
/* Ici, i vaut 2. */
return 0;
}
Passage de paramètres par référence en C++
La solution du C est exactement la même que celle du Pascal du point de vue sémantique. En fait, le Pascal
procède exactement de la même manière en interne, mais la manipulation des pointeurs est masquée par le
langage. Cependant, plusieurs problèmes se posent au niveau syntaxique :
• la syntaxe est lourde dans la fonction, à cause de l’emploi de l’opérateur * devant les paramètres ;
• la syntaxe est dangereuse lors de l’appel de la fonction, puisqu’il faut systématiquement penser à utiliser
l’opérateur & devant les paramètres. Un oubli devant une variable de type entier et la valeur de l’entier est
utilisée à la place de son adresse dans la fonction appelée (plantage assuré, essayez avec scanf).
Le C++ permet de résoudre tous ces problèmes à l’aide des références. Au lieu de passer les adresses des
variables, il suffit de passer les variables elles-mêmes en utilisant des paramètres sous la forme de références.
La syntaxe des paramètres devient alors :
type &identificateur
Exemple Passage de paramètre par référence en C++
void test(int &i) // i est une référence du paramètre constant.
{
i = 2; // Modifie le paramètre passé en référence.
return;
}
int main()
{
int i=3;
test(i); // Après l’appel de test, i vaut 2.
// L’opérateur & n’est pas nécessaire pour appeler
test.
return 0;
}
Il est recommandé, pour des raisons de performances, de passer par référence tous les paramètres dont la
copie peut prendre beaucoup de temps (en pratique, seuls les types de base du langage pourront être passés
par valeur).
Utilisation des pointeurs avec les tableaux
Les tableaux sont étroitement liés aux pointeurs parce que, de manière interne, l’accès aux éléments des
tableaux se fait par manipulation de leur adresse de base, de la taille des éléments et de leurs indices. En
fait, l’adresse du n-ième élément d’un tableau est calculée avec la formule :
Adresse_n = Adresse_Base + n*taille(élément)
où
- taille(élément) représente la taille de chaque élément du tableau
- Adresse_Base l’adresse de base du tableau. Cette adresse de base est l’adresse du début du tableau, c’est
donc à la fois l’adresse du tableau et l’adresse de son premier élément.
Ce lien apparaît au niveau du langage dans les conversions implicites de tableaux en pointeurs, et dans
le passage des tableaux en paramètre des fonctions.
Conversions des tableaux en pointeurs
Afin de pouvoir utiliser l’arithmétique des pointeurs pour manipuler les éléments des tableaux, le C++
effectue les conversions implicites suivantes lorsque nécessaire :
tableau vers pointeur d’élément ;
pointeur d’élément vers tableau.
Cela permet de considérer les expressions suivantes comme équivalentes :
identificateur[n]
et :
*(identificateur + n)
si identificateur est soit un identificateur de tableau, soit celui d’un pointeur.
Exemple: Accès aux éléments d’un tableau par pointeurs
int tableau[100];
int *pi=tableau;
tableau[3]=5; /* Le 4ème élément est initialisé à 5 */
*(tableau+2)=4; /* Le 3ème élément est initialisé à 4 */
pi[5]=1; /* Le 6ème élément est initialisé à 1 */
Paramètres de fonction de type tableau ou Passage d’un tableau
en paramètre d’une fonction
La conséquence la plus importante de la conversion tableau vers pointeur se trouve dans
le passage par variable des tableaux dans une fonction. Lors du passage d’un tableau en
paramètre d’une fonction, la conversion implicite a lieu, les tableaux sont donc toujours
passés par variable, jamais par valeur.
Par ailleurs, certaines caractéristiques des tableaux peuvent être utilisées pour les passer en
paramètre dans les fonctions.
Il est autorisé de ne pas spécifier la taille de la dernière dimension des paramètres de
type tableau dans les déclarations et les définitions de fonctions. Cependant, pour les
dimensions deux et suivantes, les tailles des premières dimensions restent nécessaires.
Exemple : Passage de tableau en paramètre d’une fonction
int tab[10][20];
void test(int t[][20])
{
/* Utilisation de t[i][j] ... */
return;
}
int main()
{
test(tab); /* Passage du tableau en paramètre. */
return 0;
}
Exemple: Considérons la fonction qui prend un tableau comme argument avec un autre argument et en
fonction des arguments passés, elle retournera la moyenne des nombres passés à travers le tableau.
#include <iostream>
using namespace std;
//Prototype de la fonction
double average(double array[], int count);
int main()
{
double values[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
cout << endl
<< "Average = "
<< average(values, (sizeof values)/(sizeof values[0]));
cout << endl;
return 0;
}
// Function de calcul de la moyenne arithmetique du tableau
double average(double array[], int count)
{ double sum = 0.0;
for(int i = 0; i<count; i++)
sum += array[i];
return sum/count;
}
#include <iostream>
#include <math.h>
using namespace std;
/* Cette méthode affiche le carré de chacun des éléments du tableau multidimensionnelle */
void square(int arr[2][3]){
int temp;
for(int i=0; i<2; i++){
for(int j=0; j<3; j++){
temp = arr[i][j];
cout<<pow(temp, 2)<<endl;
}
}
}
int main(){
int arr[2][3] = {
{1, 2, 3},
{4, 5, 6}
};
square(arr);
return 0;
}
