Kant1/French_Wikibooks_articles · Datasets at Hugging Face

text stringlengths 0 211k
getchar();
return 0;
Le résultat :
x \|\| sin cos tan acos asin atan
0.1 \|\| 0.100 0.995 0.100 1.471 0.100 0.100
0.2 \|\| 0.199 0.980 0.203 1.369 0.201 0.197
0.3 \|\| 0.296 0.955 0.309 1.266 0.305 0.291
0.4 \|\| 0.389 0.921 0.423 1.159 0.412 0.381
0.5 \|\| 0.479 0.878 0.546 1.047 0.524 0.464
Remarque :
Au démarrage :
Au final :
Avec résultat à l'écran.
/* ------------------------------ */
int main(void)
double (*TrigF[6])(double x) = {atan,asin,acos,tan,cos,sin};
int i= 6;
double x= .1;
for(;x<=.5;x+=.1)
printf("\n");
for(i=6;i;) printf(" %.3f ",TrigF[--i](x));
printf("\n\n Press return to continue.\n");
getchar();
return 0;
Deuxième exemple.
Nous voulons créer la fonction Derivate capable de calculer la dérivé première et seconde d'une fonction, en utilisant un tableau de pointeurs de fonctions.
Déclaration d'un tableau de pointeurs de fonctions.
double (Derivate[3])(double (P_f)(double x),double a,double h) = {fx,Dx_1,Dx_2};
Exemple d'un appel.
f(x)=Derivate[0](f,x,0.)
Exemple à tester.
/* ------ Fonction f ------------ */
char feq[] = "x**2";
/* ------ Fonction g ------------ */
double g(double x){return(
char geq[] = "cos(x)**2+sin(x)+x-3";
double fx(
double (*P_f)(double x),
double a,
double h
return( ((*P_f)(a)) );
f'(a) = f(a+h) - f(a-h)
2h
double Dx_1(
double (*P_f)(double x),
double a,
double h
return( ( ((P_f)(a+h))-((P_f)(a-h)) ) / (2.*h) );
f"(a) = f(a+h) - 2 f(a) + f(a-h)
h**2
double Dx_2(
double (*P_f)(double x),
double a,
double h
return( (((P_f)(a+h))-2((P_f)(a))+((P_f)(a-h))) / (h*h) );
int main(void)
double (Derivate[3])(double (P_f)(double x),
double a,
double h) = {fx,Dx_1,Dx_2};
double x = 2;
double h = 0.001;
printf("\n\n");
printf(" f(%.3f) = %.3f = %.3f \n",x,f(x), Derivate[0](f,x,0.));
printf(" f'(%.3f) = %.3f = %.3f \n",x,Dx_1(f,x,h),Derivate[1](f,x,h));
printf("f"(%.3f) = %.3f = %.3f \n",x,Dx_2(f,x,h),Derivate[2](f,x,h));
printf("\n\n");
printf(" g(%.3f) = %.3f = %.3f \n",x,g(x), Derivate[0](g,x,0.));
printf(" g'(%.3f) = %.3f = %.3f \n",x,Dx_1(g,x,h),Derivate[1](g,x,h));
printf("g"(%.3f) = %.3f = %.3f \n",x,Dx_2(g,x,h),Derivate[2](g,x,h));
printf("\n\n Press return to continue.");
getchar();
return 0;



Programmation C/Fonctions et procédures

Définition.
Le code suivant définit une fonction codice_1 renvoyant une valeur de type codice_2 et prenant N arguments, codice_3 de type codice_4, codice_5 de type codice_6, etc.
type_retour fonction(type1 par1, type2 par2, /* ..., */ typeN parN)
/* Déclarations de variables ... */
/* Instructions ... */
L'exécution d'une fonction se termine soit lorsque l'accolade fermante est atteinte, soit lorsque le mot clef codice_7 est rencontré. La valeur renvoyée par une fonction est donnée comme paramètre à codice_7.
Une procédure est une fonction renvoyant codice_9, dans ce cas codice_7 est appelé sans paramètre.
Les passages des arguments aux fonctions se font toujours "par valeur". Si on veut modifier la valeur d'un argument passé en paramètre à une fonction, en dehors de cette même fonction, il faut utiliser des pointeurs.
Déclaration par prototype.
Le prototype d'une fonction correspond simplement à son en-tête (tout ce qui précède la première accolade ouvrante). C'est-à-dire son nom, son type de retour et les types des différents paramètres. Cela permet au compilateur de vérifier que la fonction est appelée avec le bon nombre de paramètres et surtout avec les bons types. La ligne suivante "déclare" la fonction codice_1, mais sans la "définir" :
type_retour nom_fonction(type1, type2, /* ..., */ typeN);
À noter que les noms des paramètres peuvent être omis et que la déclaration doit se terminer par un point-virgule (;), sans quoi vous pourrez vous attendre à une cascade d'erreurs.
Absence des paramètres.
Avant la normalisation par l'ANSI, il était possible de faire une déclaration partielle d'une fonction, en spécifiant son type de retour, mais pas ses paramètres:
int f();
Cette déclaration ne dit rien sur les éventuels paramètes de la fonction codice_12, sur leur nombre ou leur type, au contraire de :
int g(void);
qui précise que la fonction codice_13 ne prend aucun argument.
Cette déclaration partielle laissait au compilateur le soin de compléter la déclaration lors de l'appel de la fonction, ou de sa définition. On perd donc un grand intérêt des prototypes. Mais à cause de "l'immense" quantité de code existant qui se reposait sur ce comportement, l'ANSI (puis le WG14) n'ont pas interdit de tels programmes, mais ont déclaré dès le C90 que cette construction est "obsolète".
Évaluation des arguments.
La norme du langage ne spécifie pas l'ordre d'évaluation des arguments. Il faut donc faire particulièrement attention aux effets de bords.
int somme(int a, int b)
int main(void)

getchar();

return 0;

Le résultat :

x || sin cos tan acos asin atan

0.1 || 0.100 0.995 0.100 1.471 0.100 0.100

0.2 || 0.199 0.980 0.203 1.369 0.201 0.197

0.3 || 0.296 0.955 0.309 1.266 0.305 0.291

0.4 || 0.389 0.921 0.423 1.159 0.412 0.381

0.5 || 0.479 0.878 0.546 1.047 0.524 0.464

Remarque :

Au démarrage :

Au final :

Avec résultat à l'écran.

/* ------------------------------ */

int main(void)

double (*TrigF[6])(double x) = {atan,asin,acos,tan,cos,sin};

int i= 6;

double x= .1;

for(;x<=.5;x+=.1)

printf("\n");

for(i=6;i;) printf(" %.3f ",TrigF[--i](x));

printf("\n\n Press return to continue.\n");

getchar();

return 0;

Deuxième exemple.

Nous voulons créer la fonction Derivate capable de calculer la dérivé première et seconde d'une fonction, en utilisant un tableau de pointeurs de fonctions.

Déclaration d'un tableau de pointeurs de fonctions.

double (*Derivate[3])(double (*P_f)(double x),double a,double h) = {fx,Dx_1,Dx_2};

Exemple d'un appel.

f(x)=Derivate[0](f,x,0.)

Exemple à tester.

/* ------ Fonction f ------------ */

char feq[] = "x**2";

/* ------ Fonction g ------------ */

double g(double x){return(

char geq[] = "cos(x)**2+sin(x)+x-3";

double fx(

double (*P_f)(double x),

double a,

double h

return( ((*P_f)(a)) );

f'(a) = f(a+h) - f(a-h)

2h

double Dx_1(

double (*P_f)(double x),

double a,

double h

return( ( ((*P_f)(a+h))-((*P_f)(a-h)) ) / (2.*h) );

f"(a) = f(a+h) - 2 f(a) + f(a-h)

h**2

double Dx_2(

double (*P_f)(double x),

double a,

double h

return( (((*P_f)(a+h))-2*((*P_f)(a))+((*P_f)(a-h))) / (h*h) );

int main(void)

double (*Derivate[3])(double (*P_f)(double x),

double a,

double h) = {fx,Dx_1,Dx_2};

double x = 2;

double h = 0.001;

printf("\n\n");

printf(" f(%.3f) = %.3f = %.3f \n",x,f(x), Derivate[0](f,x,0.));

printf(" f'(%.3f) = %.3f = %.3f \n",x,Dx_1(f,x,h),Derivate[1](f,x,h));

printf("f"(%.3f) = %.3f = %.3f \n",x,Dx_2(f,x,h),Derivate[2](f,x,h));

printf("\n\n");

printf(" g(%.3f) = %.3f = %.3f \n",x,g(x), Derivate[0](g,x,0.));

printf(" g'(%.3f) = %.3f = %.3f \n",x,Dx_1(g,x,h),Derivate[1](g,x,h));

printf("g"(%.3f) = %.3f = %.3f \n",x,Dx_2(g,x,h),Derivate[2](g,x,h));

printf("\n\n Press return to continue.");

getchar();

return 0;

Programmation C/Fonctions et procédures

Définition.

Le code suivant définit une fonction codice_1 renvoyant une valeur de type codice_2 et prenant N arguments, codice_3 de type codice_4, codice_5 de type codice_6, etc.

type_retour fonction(type1 par1, type2 par2, /* ..., */ typeN parN)

/* Déclarations de variables ... */

/* Instructions ... */

L'exécution d'une fonction se termine soit lorsque l'accolade fermante est atteinte, soit lorsque le mot clef codice_7 est rencontré. La valeur renvoyée par une fonction est donnée comme paramètre à codice_7.

Une procédure est une fonction renvoyant codice_9, dans ce cas codice_7 est appelé sans paramètre.

Les passages des arguments aux fonctions se font toujours "par valeur". Si on veut modifier la valeur d'un argument passé en paramètre à une fonction, en dehors de cette même fonction, il faut utiliser des pointeurs.

Déclaration par prototype.

Le prototype d'une fonction correspond simplement à son en-tête (tout ce qui précède la première accolade ouvrante). C'est-à-dire son nom, son type de retour et les types des différents paramètres. Cela permet au compilateur de vérifier que la fonction est appelée avec le bon nombre de paramètres et surtout avec les bons types. La ligne suivante "déclare" la fonction codice_1, mais sans la "définir" :

type_retour nom_fonction(type1, type2, /* ..., */ typeN);

À noter que les noms des paramètres peuvent être omis et que la déclaration doit se terminer par un point-virgule (;), sans quoi vous pourrez vous attendre à une cascade d'erreurs.

Absence des paramètres.

Avant la normalisation par l'ANSI, il était possible de faire une déclaration partielle d'une fonction, en spécifiant son type de retour, mais pas ses paramètres:

int f();

Cette déclaration ne dit rien sur les éventuels paramètes de la fonction codice_12, sur leur nombre ou leur type, au contraire de :

int g(void);

qui précise que la fonction codice_13 ne prend aucun argument.

Cette déclaration partielle laissait au compilateur le soin de compléter la déclaration lors de l'appel de la fonction, ou de sa définition. On perd donc un grand intérêt des prototypes. Mais à cause de "l'immense" quantité de code existant qui se reposait sur ce comportement, l'ANSI (puis le WG14) n'ont pas interdit de tels programmes, mais ont déclaré dès le C90 que cette construction est "obsolète".

Évaluation des arguments.

La norme du langage ne spécifie pas l'ordre d'évaluation des arguments. Il faut donc faire particulièrement attention aux effets de bords.

int somme(int a, int b)

int main(void)