Faculté Informatique & Communications Cours d'informatique

Mini-Référence :
les fonctions en C++

Il est possible de déclarer, à l'intérieur d'un bloc, une variable ou une constante avec un identificateur déjà utilisé pour une entité externe au bloc (i.e. une autre variable, constante, fonction,...). On se trouve alors avec deux variables qui portent le même nom. Dans ce cas, la variable globale (externe) est masquée par la variable locale, entre l'instant/le lieu de sa déclaration et la fin du bloc dans lequel s'est faite cette déclaration. Pendant toute la durée de vie (i.e. la portée) de la variable locale, il n'est plus possible de référencer la variable globale (Cela n'est toutefois pas tout à fait exact, il existe bien un moyen mais nous ne le verrons qu'au prochain semestre.).

Exemple :

Résultat :

La variable locale   i  vaut : 3
La constante locale var vaut : 4
La variable locale   i  vaut : 2
La variable globale var vaut : 1

Syntaxe :

type nom ( type1 arg1, ..., typen argn);

où:

• type est le type de la fonction, c'est-à-dire le type de la valeur retournée par la fonction
• type_i est le type du i^ème argument et arg_i son identificateur (au niveau de la fonction)

Remarques:

• Toute fonction doit être prototypée (i.e. déclarée) avant d'être invoquée.
• Le prototypage d'une fonction se termine par un point-virgule.

Exemple :

type nom ( type1 arg1, ..., typen argn)
{
  // corps de la fonction
  ...
  return valeur;
}

Remarques:

• Dans le cas où la fonction ne retourne rien le type de retour est (par convention) le type particulier void dans ce cas, la clause return est optionnelle, et si elle est malgré tout présente, elle n'est pas suivie d'une valeur de retour.
• Dans le cas où la fonction n'admet pas d'argument, la liste des arguments est par convention: (). (Pensez par exemple à la fonction main).

Exemple:

Exemple :

//
// Prototypages
//
void titre();
bool divisible (const int a, const int b);

//
// Fonction principale:
// exemple d'invocations
//
void main()
{
    const bool res(divisible(5,9)); //exemple d'appel pour une initialisation
    titre();
    // voir la remarque ci-après pour l'explication de '(cond ? vrai : faux)'
    cout << "Test 4 et 2: " << (divisible(4,2) ? "oui" : "non") << endl
         << "Test 4 et 0: " << (divisible(4,0) ? "oui" : "non") << endl
         << "Test 4 et 3: " << (divisible(4,3) ? "oui" : "non") << endl;
}


//
// définition d'une fonction booléenne,
// admettant deux arguments entiers, et vraie dans le cas où la
// division entière est possible, sans reste.
//
bool divisible (const int a, const int b)
{
    return ( (b != 0) && (a % b == 0) );
}


//
// Fonction sans argument, et ne retournant rien.
//
void titre ()
{
    cout << "Titre de l'exercice" << endl;
    cout << "par Mme Pahut" << endl << endl;
}

Résultat :

Titre de l'exercice
par Mme Pahut

Test 4 et 2: oui
Test 4 et 0: non
Test 4 et 3: non

Remarque :

La syntaxe :

Attention toutefois,action1 et action2 ne correspondent pas à des blocs d'instructions, mais sont des instructions simples.

#include <cmath>

• M_PI : valeur approchée de pi

• sqrt(x) : calcule la racine carrée de x.
• log(x)  : calcule le logarithme népérien de x.
• exp(x)  : calcule l'exponentielle de x.
• sin(x)  : calcule le sinus de x (x en radians)
• cos(x)  : calcule le cosinus de x (x en radians)
• acos(x) : calcule la réciproque du cosinus (arccosinus, noté parfois cos^-1)
• asin(x) : calcule la réciproque du sinus (arcsinus, noté parfois sin^-1)
• pow(x,y): calcule x puissance y (si y n'est pas entier, x doit être strictement positif)

Ces fonctions renvoient des valeurs de type double. On peut par exemple écrire : double x; x = sqrt(2.0);