2.fonctions.md

Fonctions

Déclaration / Définition

Exemple de déclaration :

type nom(paramètres)
int somme(int, int);

Exemple de définition :

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

• Toute fonction doit être déclarée avant son premier appel
• La définition d’une fonction détaille son implémentation
• Une fonction permet de regrouper du code et ainsi de le rendre plus clair
• Les fonctions ont un type de retour

int carre(int x) {
    return x*x;
}

• Pour faire une procédure, on utilise void comme type de retour

void afficheNb(int nb){
    cout << nb << endl;
}

Signature d'une fonction

La signature d’une fonction est le type des paramètres en entrée. 2 fonctions ne peuvent avoir le même nom que si leur signature est différente (on parle de surcharge de fonction).

Exemple :

float test(int i, int j){
    return i+j;
}

float test(float i, float j){
    return i*j;
}
//Les 2 signatures (int,int) et (float,float) sont différentes, donc ok.

Valeur par défaut

On peut donner des valeurs par défaut à certains paramètres. Ceux-ci doivent être en dernier dans la liste des paramètres.

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

int result = somme(3) //result = 5

Attention sur l’utilisation des valeurs par défaut avec la surcharge de fonction.

Appel de fonctions

Pour appeler une fonction, on utilise son identificateur suivi des parenthèses et des valeurs données aux paramètres.

int resultat;
resultat = somme(2,3);
int i = 2;
int j = 3;
resultat = somme(i,j);

Variables statiques

• Une variable statique locale à une fonction est une variable qui naît au premier appel de la fonction et qui meurt à la fin du programme.
• Cette variable est unique pour tout le programme et pour tous les appels à cette fonction.
• Elle doit être initialisée lors de sa définition.

void maFontion(int n){
    static unsigned int nbAppel = 0; //déclaration et initialisation
    //incrémente la variable à chaque appel de la fonction reste du code de la fonction
    ++nbAppel;
}

Exercice 3

Structure de données

• C’est un regroupement de variables de types différents pour définir un nouveau type
• Les variables sont appelées membres de la structure
• L’accès au champs se fait grâce à la notation pointée

struct Coord3D {
    double x, y, z;
}; //crée le type Coord3D

Coord3D pt1 = {0. , 0. , 0.};
Coord3D pt2 = pt1; // Omission de struct valide seulement en C++
pt1.x = 10; // Changement de la valeur de x de pt1

Les énumérations

• Définissent un nouveau type de données à valeur dans un ensemble prédéfini.
• Gérés comme des entiers par le compilateur.
• Peut s’utiliser avec les tests switch

enum Couleur { ROUGE , VERT , BLEU };
Couleur uneCouleur = ROUGE; //uneCouleur ne peut contenir que ROUGE, VERT ou BLEU

bool estRouge (Couleur c)
{
    return c == ROUGE ;
}
cout << estRouge ( BLEU ) << endl; // affiche 0

Les alias

Le mot clé typedef permet de définir un alias (ou raccourci) vers un type de données.

typedef std::vector <double>::iterator iterateur; 
iterateur it; //it est de type std::vector <double>::iterator

Organisations des fichiers

• Pour une plus grande lisibilité et réutilisabilité du code, il est conseillé d’organiser le code en fichiers séparés qui regroupent chacun les structures de données et les fonctions qui leur sont associées.

On utilise 2 type de fichiers :

• Les fichiers d’en-tête ou header « .h » qui contiennent les définitions des structures et les déclarations de fonctions.
• Les fichiers « .cpp » qui contiennent les définitions des fonctions et dans lesquels on inclut le fichier « .h » correspondant.
• Pour éviter les inclusions multiples (quand un fichier d’en-tête est inclus plusieurs fois dans un projet), on utilise des guard blocks au début des fichiers d’en-tête.

# ifndef COMPLEXE_H // si COMPLEXE_H n’est pas défini (sinon on saute au #endif
# define COMPLEXE_H // définit  struct Complexe

//définition structures et déclarations des fonctions

# endif

Exercice 4