Les fonctions

C++ ne permet que des fonctions (pas

de procédures).

Une procédure peut être écrite en

utilisant une fonction ne renvoyant
pas de valeur.

1
 Définition des fonctions

type identificateur(paramètres)
{
... // Instructions de la fonction.
}

 type est le type de la valeur renvoyée,

 identificateur est le nom de la fonction,
 Paramètres est une liste de paramètres.

2
 Syntaxe de la liste des paramètres

type variable [= valeur] [, type variable [= valeur] [...]]

 type est le type du paramètre (variable) qui le suit

 valeur est sa valeur par défaut.

La valeur par défaut d’un paramètre est la valeur que ce

paramètre prend lors de l’appel de la fonction si aucune
autre valeur n’est fournie.

Note: L’initialisation des paramètres de fonctions n’est

possible qu’en C++.

3
La valeur renvoyée par la fonction est spécifiée en utilisant la
commande return, dont la syntaxe est :
return valeur ;

Exemple: Définition de fonction somme

int somme (int i, int j)
{
return i+j;
}

 Si une fonction ne renvoie pas de valeur, on lui donnera le type

void.
 Si elle ne prend pas de paramètres, sa liste de paramètres sera
void ou n’existe pas.
 Il n’est pas nécessaire de mettre une instruction return à la fin
d’une fonction qui ne renvoie pas de valeur.
4
 Appel des fonctions

 L’appel d’une fonction se fait en donnant son

nom, puis les valeurs de ses paramètres entre
parenthèses.
Attention ! Même s’il n’y a pas de paramètres, il
faut mettre les parenthèses, sinon la fonction
n’est pas appelée.

Exemple:
int i=somme(2,3); // appel de la fonction somme
5
 Si la déclaration comprend des valeurs par
défaut, ces valeurs sont utilisées lorsque ces
paramètres ne sont pas fournis lors de
l’appel.

 Si un paramètre est manquant, alors tous les

paramètres qui le suivent doivent aussi
l’être.

 Il en résulte que seuls les derniers

paramètres d’une fonction peuvent avoir
des valeurs par défaut.
6
Exemple :
int test (int i = 0, int j = 2)
{
return i/j ;
}

 L’appel de la fonction test(8) est valide. Comme on ne

précise pas le dernier paramètre, j est initialisé à 2. Le résultat est
donc 4.

 De même, l’appel test() est valide : dans ce cas i =0 et j =2.

 En revanche, il est impossible d’appeler la fonction test en

ne précisant que la valeur de j.

 Enfin, l’expression int test(int i=0, int j) {...} serait invalide,

car si on ne passait pas deux paramètres, j ne serait pas initialisé.7
 Déclaration des fonctions (prototypage)

Le rôle des déclarations est de signaler l’existence des

fonctions au compilateur afin de les utiliser, tout en
reportant leurs définitions plus loin ou dans un autre
fichier.
 Toute fonction doit être déclarée avant d’être appelée
pour la première fois. La définition d’une fonction fait
office de déclaration.
 Il existe des cas où une fonction doit être appelée dans
une autre fonction définie avant elle. Comme cette
fonction n’est pas définie au moment de l’appel, elle
doit être déclarée.
 il est courant d’avoir à appeler une fonction définie
dans un autre fichier que celui d’où se fait l’appel. 8
Syntaxe:
type identificateur(paramètres) ;

Exemple:
int Min(int, int) ; //Déclaration de la fonction minimum définie plus loin

int main(void) //Fonction principale

{
int i = Min(2,3); //Appel de la fonction Min, déjà déclarée.
return 0;
}

int Min(int i, int j) /* Définition de la fonction min. */

{
if (i<j) return i;
else return j;
}

9
 Fonctions inline

Ce sont des fonctions dont le code est incorporé

par le compilateur dans le module objet
correspondant à chaque appel.
Exemple:
inline double cube(double x)
{return x*x*x;}

NOTE: Une fonction inline est définie en même

temps qu’elle est déclarée.
10
 Variables locales
 Les variables locales sont celles déclarées
à l’intérieur de la fonction.
Elles sont différentes des variables de
mêmes noms qui pourraient exister dans
une autre partie du programme.
 Les variables déclarées en dehors de toute
fonction sont des variables globales.
Les variables locales perdent leurs valeurs
une fois la fonction terminée.
11
Exemple: (A essayer en TP)

#include<iostream>
Using namespace std;
int x=1,y= 2; // variables globales
void var_local(void); // prototype de la fonction
/************************/
main()
{
cout<<"avant d'appeler la fonction var_local, x="<<x <<"et y ="<<y<<"\n";
var_local();
cout<<"après l'appel de la fonction var_local,x="<<x <<"et y ="<<y<<"\n";
return 0;
}
/*******************************/
void var_local(void) // définition de la fonction
{int x=88, y=99; // variables locales
cout<<"dans la fonction var_local, x="<<x <<« et y = "<<y<<"\n";
}
12
 Variables statiques
Une variable statique, et généralement initialisée, maintient sa valeur entre
les appels des fonctions.
Exemple: (A essayer en TP)

include<iostream>
Using namespace std;
double mean (double x)
{static double N=0;
static double S=0;
N++;
S+=x;
return S/N;}
/*******************************/
main()
{cout<<"mean(1)= " <<mean(1)<<"\n";
cout<<"mean(2)= " <<mean(2)<<"\n";
cout<<"mean(4)= " <<mean(4)<<"\n";
cout<<"mean(10)= " <<mean(10)<<"\n";
cout<<"mean(11)= " <<mean(11)<<"\n";
return 0;
13
}
 Surcharge des fonctions
(function overloading)

 Caractéristique unique du C++

 Plusieurs fonctions ayant le même nom mais
différents types de paramètres peuvent être
déclarées.
 La liste de ces types s’appelle la signature de
la fonction.

14
Exemple1:
#include <iostream>
Using namespace std;

void inc(int& i) /*********PREMIERE DEFINITION********/

{
i+=1;
}

void inc(float& x) /*********DEUXIEME DEFINITION********/

{
x+=1;
}

void inc(char& c) /*********TROISIEME DEFINITION********/

{
c+=1;
} 15
main() /*************FONCTION PRINCIPALE******/
{
char c='A';
int i=10;
float x=10.2;
cout<<"c="<<c<<"\n"<<"i="<<i<<"\n"<<"x="<<x<<"\n";
inc(c);
inc(i);
inc(x);
cout<<"valeurs des variables après exécution:\n "
<<"c="<<c<<"\n"<<"i="<<i<<"\n"<<"x="<<x;
return 0;
}

16
Exemple2:
#include <iostream>
Using namespace std;

// Surcharge de la fonction abs de 2 façons

int abs (int n);
double abs (double n);

int main( ) {
cout<< "valeur absolue de -10: "<< abs(-10)<< "\n";
cout<<"valeur absolue de -10.01:"<<abs(-10.01)<<"\n";
return 0;
}
// abs( )pour entiers
int abs (int n) {
cout << "Pour les entiers abs( )\n";
return n<0 ? -n : n;
}
// abs( ) pour réels double précision
double abs (double n) {
cout << "pour les réels double précision abs( )\n";
return n<0 ? -n : n;
} 17
 La fonction main

 Lorsqu’un programme est chargé, son

exécution commence par l’appel d’une
fonction spéciale.
 Cette fonction doit impérativement s’appeler
"main" (principal en anglais) pour que le
compilateur puisse savoir que c’est cette
fonction qui marque le début du programme.
 La valeur 0 retournée par la fonction main
indique que tout s’est déroulé correctement.

18
 Les fonctions d’entrée-sortie de base

 printf ("print formatted" en anglais): permet

d’afficher des données à l’écran.
 scanf "scan formatted ": permet de les lire
à partir du clavier.
 Elles attendent toutes les deux une chaîne de
caractères au premier paramètre.
 Elles sont définies dans le fichier <cstdio.h>

19
 La fonction printf

Syntaxe:
printf(chaîne de format [, valeur [, valeur [...]]])

La chaîne de format peut contenir du texte, mais

surtout elle doit contenir autant de formateurs
que de variables à afficher.
Les formateurs sont placés dans le texte là où les
valeurs des variables doivent être affichées.

20
La syntaxe des formateurs est la suivante :

%[[indicateur]...][largeur][.précision][taille] type

 Un formateur commence donc toujours par le

caractère %.

 Pour afficher ce caractère (%) sans faire un

formateur, il faut le dédoubler (%%).

21
Le type de la variable à afficher est aussi obligatoire.
Type de données à afficher Caractère de formatage

Entier décimal signé d

Entier décimal non signé u ou i
Entier octal non signé o
Entier hexadécimal non signé x (avec les caractères ’a’ à ’f’)
ou X
(avec les caractères ’A’ à ’F’)
Flottants f, e, g, E ou G
Caractère c
Chaîne de caractères s
Pointeur p

22
 La fonction scanf

Syntaxe:

scanf(chaîne de format, &variable [, &variable [...]]) ;

& indique une référence

23
Exemple: (A tester en TP)
#include <cstdio>
int main ()
{
char str [80];
int i;
printf ("Entrez votre nom de famille: ");
scanf ("%s",str);
printf ("Entrez votre âge: ");
scanf ("%d",&i);
printf ("Mr./Mme %s a %d ans.\n",str,i);
printf ("Votre âge en hexadécimal est %#x (%d).\n",i,i);
return 0; ?
}
24
 Exemple

#include <cstdio> // Autorise l’emploi de printf et de scanf.

long double x, y;
int main(void)
{
printf("Calcul de moyenne\n"); /* Affiche le titre. */
printf("Entrez le premier nombre : ");
scanf("%Lf", &x); /* permet de saisir le premier nombre. */
printf("\nEntrez le deuxième nombre : ");
scanf("%Lf", &y); /* saisie du deuxième nombre. */
printf("\nLa valeur moyenne de %Lf et de %Lf est %Lf.\n",
x, y, (x+y)/2);
return 0;
}
25