Avant toute chose, par defaut en C/C++ , les arguments sont passés par valeur
(sauf les tableaux).
 
  Egalement : une fonction ne peut pas être définie à l'intérieur d'une autre fonction
 

 voir ici les passages par référence et par pointeur

 voir ici les passages de fonctions en argument d'autres fonctions
 
 
 
 

Exemple de définition de fonction

double f0(double x, double y)
{
double z;
z=x*x+y;
return z;
}

appel par

double a,b,c;
a=f0(b,c);
 
 

Une fonction n'a pas forcément d'argument

int un()
{
cout << "fonction un";
return 1;
}

 appel par

int i0;
i0=un();
 
 
 
 
 
 
 
 
 

Une fonction peut être de type void (vide: une procedure en fait)

void imprime( char c)
{
cout << c <<endl ;
return;          // le return est facultatif dans ce cas
}

appel par

char c0;
imprime(c0);
 
 

Les fonctions sont declarées avant le programme principal

#include <iostream>

using namespace std;

float x2=6.0;                 //   variable globale
float cube(float x)
{
return(x*x*x);
}
int main()
{
float x0,y;
x0=x2;
y=cube(x0);
cout << y << endl;
return 0;
}
 
 

On peut aussi n'écrire que l'interface (le prototype) de la fonction avant le programme principal
(l'implémentation étant écrite a un autre endroit)

#include <iostream>

using namespace std;

float x2=6.0;                 //   variable globale
float cube(float x);         //  attention au point virgule dans ce cas

int main()
{
float x0,y;
x0=x2;
y=cube(x0);
cout << y << endl;
return 0;
}

float cube(float x)
{
return(x*x*x);
}
 
 
 
 
 
 
 

Les interfaces et implémentations des différentes fonctions se trouveront dans des fichiers différents pour de gros projets. Dans l'exemple précédent , la ligne

float cube(float x);

se trouverait dans le fichier cube.h, l'implémentation dans le fichier cube.cpp, et on aurait au début la ligne

#include "cube.h"
 
 
 

Les fonctions peuvent etre récursives

void recursive(int n)
{
int profondmax=10;
if  (n== profondmax) return;
else
{
// inserez votre code ici
recursive(n+1);
}
return;
}

 appel par

recursive(1);
 
 
 

En C++, une fonction peut avoir des arguments par défaut
 

float ajoute( float x=1.0, float y=2.0)
{
return x+y;
}

 appel par

float z;
z=ajoute(3,4);     // 3+4
z=ajoute(3);        // 3 + 2 (valeur par defaut)
z=ajoute();          // 1 + 2 ( les 2 arguments prennent leur valeur par defaut)
//   Attention, on ne peut pas donner au 1er argument sa valeur par defaut
//     tout en modifiant le 2ieme
 
 

En C++, une fonction peut être inline

On rajoute inline devant la fonction, la fonction est remplacée automatiquement par son contenu partout dans le programme.

inline float sqr(float x)
{
return x*x;
}
 
 
 

Les variables sont réinitialisées a chaque appel, sauf si on les déclare static
 

#include <iostream>

using namespace std;

double incremente( double x)
{
static double total = 0 ;     // initialisé seulement au debut
total += x;
return total;
}
int main()
{
double y;
y = incremente(10);
cout << y << endl;
y = incremente(20);
cout << y <<endl;
return 0;
}
 
 
 
 
 

Des fonctions similaires opérant avec des arguments de type différents ou un nombre différent d'arguments peuvent avoir le meme nom, on appelle cela  surcharge .