Fonction ceil non fonctionnelle

Version imprimable

1 pièce(s) jointe(s)

Bonjour,

Débutant en langage c j'en viens à utiliser les fonctions, dans le premier exemple la fonction fabs fonctionne, dans le second exemple la fonction ceil ne fonctionne pas, pourquoi?
J'ai déjà eu l'occasion de me servir des fonctions fabs et ceil sans rencontrer de problèmes.
J'utilise code blocks comme ide

La fonction fabs qui fontcionne :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <stdio.h> #include <stdlib.h> #include <math.h> double fabs(double nbre) { return fabs(nbre); } int main() { double nbre; printf("\n Entre un nombre négatif décimal : \n"); scanf("%lf",&nbre); printf("\n La valeur absolue de %.3f est %.3f \n", nbre, fabs(nbre)); return main(); //return main fera tourner la fonction en boucle }
La fonction ceil qui ne fontcionne pas :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <stdio.h> #include <stdlib.h> #include <math.h> double ceil(double nbre) { return ceil(nbre); } int main() { double nbre; printf("\n Entre un nombre négatif décimal : \n"); scanf("%lf",&nbre); printf("\n L'arrondi à l'entier supérieur de %f est %f \n", nbre, ceil(nbre)); return main(); //return main fera tourner la fonction en boucle }
Quelque soit mes tentatives avec la fonction ceil voilà ce que j'obtiens avec la console :

Pièce jointe 479278

Merci par avance pour vos réponses,

Nicolas.

30/05/2019, 00h47
dalfab

Bonjour,

C'est en effet curieux. Dans les deux cas ça devrait planter rapidement. Une fonction ne peut pas s'appeler elle-même inconditionnellement. Il y a la même erreur dans main() mais là le plantage ne se déclenchera qu'après un temps plus important.
Peut-être que dans le cas de fabs() le compilateur n'envisage même pas la fonction définie car elle est intrinsèque, mais c'est en effet curieux que ça ne plante pas dans ce cas.

En C++, il y aurait une possibilité, une fonction fabs() C++ pourrait appeler une fonction fabs() du C. Mais un compilateur C++ doit refuser de compiler une fonction main() qui appelle main() il ne laisserait pas passer cette erreur. Donc supposer que c'est compilé en C++ n'est pas plausible.

Par contre, tu confirmes que si tu supprimes les 2 fonctions déclarées avant main() tu obtiens bien 2 codes qui fonctionnent tout à fait normalement?

Je pense que c'est [un problème]/ [la magie] de la portée :koi: :koi:
Je pense qu'au moins 1 des 2 appels (1 -> main, 2 -> dans la fonction), est un appel à la bonne fonction.

Parce que si tu prends ce code ci-dessus (*) :mrgreen: :mrgreen:, tu plantes (core dumped) parce que tu dépasses la pile d'appels.

Et effectivement si tu tu prends ce code ci-dessus (**) :mrgreen: :mrgreen:, tu n'appelles pas ta fonction mais directement la bonne fonction.

* :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 #include <stdio.h> #include <stdlib.h> //#include <math.h> static int step_count = 0; double toto(double num) { ++step_count; printf("Step %d\n", step_count); return toto(num); } int main (int argc, char** argv) { double num = 11.76; printf("\n La valeur absolue de %.3f est %.3f \n", num, toto(num)); return 0; }
** :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #include <stdio.h> #include <stdlib.h> //#include <math.h> double fabs(double num) { printf("call fabs\n"); return fabs(num); } int main (int argc, char** argv) { double num = 11.76; printf("\n La valeur absolue de %.3f est %.3f \n", num, fabs(num)); return 0; }

1 pièce(s) jointe(s)

Bonjour,

Merci pour vos réponses.

Je vous confirme que la fonction fabs fonctionne seule, la fonction ceil elle ne fonctionne pas, comme mentionné dans mon premier poste.
Si je viens à supprimer les fonctions avant le main plus rien ne fonctionne, peut-être devrais-je m’inspirer du code ci-dessous pour en faire des fonctions...

Le code ci-après est un exemple simple vous montrant que je parviens à coder fabs et ceil sans fonctions, ayant déjà eu l'occasion de m'en servir :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #include <stdio.h> #include <stdlib.h> #include <math.h> int main() { double nbre, nbre_fabs, nbre_ceil, nbre_triple; printf("\n Entre un nombre négatif décimal : \n"); scanf("%lf",&nbre); nbre_fabs = fabs(nbre); printf("\n La valeur absolue de %.3f est %.3f \n", nbre, nbre_fabs); nbre_ceil = ceil(nbre); printf("\n L'arrondi à l'entier supérieur de %f est %f \n", nbre, nbre_ceil); nbre_triple = 3 * nbre; printf("\n Le triple de %.3f est = %.3f \n", nbre, nbre_triple); return main(); //return main fera tourner la fonction en boucle }
Ci-après ce que j'obtiens à la console avec le code précédent :

Pièce jointe 479354

Je reviendrai plus tard en m' étant inspiré du code précédent pour l'intégrer aux fonctions fabs et ceil

Et la programmation modulaire ? Je verrai plus tard...

30/05/2019, 14h29
Bousk

Si ta fonction fabs fonctionne c'est uniquement par chance.
Ton code de 3 lignes montre au moins 4 grosses erreurs.
Ta fonction ceil fait planter le programme après plus de 11s. C'est un peu long pour faire un ceil...
- on n'appelle jamais main dans un programme
- les fonctions récursives doivent prévoir une façon de sortir de la récursivité
- une fonction récursive doit se justifier
- tu ne veux pas (voire ne sais pas faire) de fonction récursive ici

Citation:

je parviens à coder fabs et ceil sans fonctions

Il s'agit d'un simple appel de fonction standard, où est la prouesse ? :weird:

Recoder fabs et ceil n'a de toute façon qu'un moindre intérêt.
30/05/2019, 17h25
xdelatour

Citation:

Envoyé par nl.smart

Le code ci-après est un exemple simple vous montrant que je parviens à coder fabs et ceil sans fonctions

Si, il y a bien des fonctions fabs et ceil, elles sont simplement déjà définies dans math.h. Créer de nouvelles fonctions qui portent le même nom ne peut que poser des problèmes.

2 pièce(s) jointe(s)

Encore merci à vous pour vos éclaircissements.

il va de soi que le débutant que je suis à encore du chemin devant lui, me permettre de venir chercher vos lumières me fera avancer :-)
Je ne connais pas encore les fonctions récursives et les fonctions statiques à une fonction (static int) seront abordées dans la programmation modulaire...

Ci-après 2 exemples de codes fonctionnant.

Le premier code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
double fabs(double nbre)
{
    return fabs(nbre);
}
 
double triple(double nbre_fabs)
{
    return 3 * nbre_fabs;
}
 
double tiers(double nbre_fabs)
{
    return nbre_fabs / 3;
}
 
int main()
{
    double nbre, nbre_fabs;
 
    printf("\n Entre un nombre négatif décimal : \n");
    scanf("%lf",&nbre);
 
    nbre_fabs = fabs(nbre);
 
    printf("\n La valeur absolue de %.3f est %.3f \n", nbre, fabs(nbre));
 
    printf("\n Le triple de %.3f est = %.3f \n", nbre_fabs, triple(nbre_fabs));
 
    printf("\n Le tiers de %.3f est = %.3f \n", nbre_fabs, tiers(nbre_fabs));
 
    return main(); //return main fera tourner la fonction en boucle
}

Ce qui est obtenu avec ce premier code :

Pièce jointe 479435

Le second code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
double fabs(double nbre_fabs)
{
    return fabs(nbre_fabs);
}
 
int main()
{
    double nbre, nbre_fabs, nbre_ceil, nbre_floor;
 
    printf("\n Entre un nombre négatif décimal : \n");
    scanf("%lf",&nbre);
 
    nbre_fabs = fabs(nbre);
 
    printf("\n La valeur absolue de %.3f est %.3f \n", nbre, fabs(nbre_fabs));
 
    nbre_ceil = ceil(nbre_fabs);
    printf("\n L'arrondi à l'entier supérieur de %.3f est %.3f \n", nbre_fabs, nbre_ceil);
 
    nbre_floor = floor(nbre_fabs);
    printf("\n L'arrondi à l'entier inférieur de %.3f est %.3f \n", nbre_fabs, nbre_floor);
 
    return main(); //return main fera tourner la fonction en boucle
}

Ce qui est obtenu avec ce second code :

Pièce jointe 479439

30/05/2019, 20h23
dalfab
C'est le code où tu dis qu'il ne fonctionne pas qui est à voir. Celui après avoir supprimé :
Code:

1 2 3 4 double fabs(double nbre) { return fabs(nbre); }
J'ai indiqué que ton code doit planter, c'est une erreur de ma part. Ce code produit que l'on appelle un "undefined behavior", où tout est possible y compris sembler retourner un résultat correct. Mais supprimer cette ineptie doit donner un code correct.
Attention : un code qui semble fonctionner n'est pas pour autant un code correct. Ça n'est pas pour rien qu'il existe encore de nombreux logiciels dits "buggués"
30/05/2019, 21h06
Sve@r
Citation:

Envoyé par nl.smart

Je ne connais pas encore les fonctions récursives

Une fonction récursive est une fonction qui s'appelle elle-même. Le principe est de demander à la sous-fonction de travailler sur un problème plus simple que le problème originel afin de lui fournir une solution plus simple qui lui servira à résoudre le problème plus complexe.
Et si le problème posé à la sous-fonction est encore trop complexe, celle-ci peut alors se réinvoquer de nouveau avec un problème encore simplifié et etc etc etc.

Tu es d'accord que si a() appelle b(), elle doit attendre que b() se termine pour continuer son travail. Quand "b" est invoquée, tout le contexte de "a" est mis de coté. "b" s'exécute, renvoie son résultat. Ensuite "a" reprend son contexte de travail et continue là où elle en était.
Ben ce principe peut s'appliquer aussi sur a() qui appelle a().
L'exemple le plus parlant est la factorielle. Car factorielle de 5 c'est 5 * factorielle de 4. Et factorielle de 4 c'est 4 * factorielle de 3 et etc etc etc. Il faut juste veiller à ce que chaque sous-appel reçoive un paramètre différent du précédent (sinon pas possibilité de différencier l'appel "n" de l'appel "n+1") et programmer un traitement final (sinon la récursivité ne s'arrête jamais).
Code:

1 2 3 4 int fact(n) { if n == 0 return 1; return n * fact(n-1) }
Toutefois, comme chaque niveau d'appel est en quelque sorte stocké pour laisser la place au suivant, tu auras j'espère bien conscience que ça ne peut pas se produire indéfiniment et que la récursivité est limitée par la capacité de ta mémoire.

Tout ça pour dire que main() qui appelle main(), ça ne fait pas une "boucle" comme tu le dis mais un empilement des couches d'appels. Empilement qui va faire ralentir de plus en plus ton programme jusqu'au plantage final et inéluctable.
Citation:
Envoyé par nl.smart

Code:

1 2 3 4 double fabs(double nbre_fabs) { return fabs(nbre_fabs); }
Franchement, tu peux nous dire quelle est ton idée quand tu tapes ce genre de truc ???

Merci pour vos explications, la pédagogie est bien présente.

L'idée avec fabs est simple, utiliser du code vue précédemment dans le cour en l'intégrant à ce qui suit pour assimiler, dans le cas présent les fonctions, après cela je l'intégrerai à la programmation modulaire puis les pointeurs... dans le cas de nbre_fabs j’envoie sa valeur qui est utilisée par ceil et floor

Est-ce que le code suivant, qui fonctionne, est lui aussi "undefined behavior" comme l'explique dalfab ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 #include <stdio.h> #include <stdlib.h> #include <math.h> double triple(double nbre) { return 3 * nbre; } double tiers(double nbre) { return nbre / 3; } int main() { double nbre; printf("\n Entre un nombre négatif décimal : \n"); scanf("%lf",&nbre); printf("\n Le triple de %.3f est = %.3f \n", nbre, triple(nbre)); printf("\n Le tiers de %.3f est = %.3f \n", nbre, tiers(nbre)); return 0; }

31/05/2019, 07h48
Sve@r

Citation:

Envoyé par nl.smart

L'idée avec fabs est simple, utiliser du code vue précédemment dans le cour en l'intégrant à ce qui suit pour assimiler, dans le cas présent les fonctions, après cela je l'intégrerai à la programmation modulaire puis les pointeurs... dans le cas de nbre_fabs j’envoie sa valeur qui est utilisée par ceil et floor

Le souci c'est que tu donnes à cette fonction le même nom que la fonction de la librairie mathématique. Comment ensuite tu penses que le programme va réagir s'il possède deux adresses de code différentes pour un même nom ?

Citation:

Envoyé par nl.smart

Est-ce que le code suivant, qui fonctionne, est lui aussi "undefined behavior" comme l'explique dalfab ?

Non, là pas de souci. Des fonctions au nom neutre (enfin n'existant pas ailleurs) et faisant des choses tout à fait licites ça va. Et tu aurais donné un autre nom à ta fonction litigieuse ça aurait été bon. Faut pas non plus avoir peur du UB. Tant que tu sais ce que tu fais, et que tu ne tentes pas des trucs exotiques tu n'auras aucun ennui...

ok, et maintenant les 2 codes suivants fonctionnent en ayant bien entendu tenu compte de vos explications, encore merci à vous, c'est donc résolu :-)

dalfab évoquait lui aussi le fait que je nomme une fonction déjà présente dans la bibliothèque mathématique, pour aboutir au plantage du code.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
double f(double nbre_fabs)
{
    return fabs(nbre_fabs);
}
double c(double nbre_ceil)
{
    return ceil(nbre_ceil);
}
double fl(double nbre_floor)
{
    return floor(nbre_floor);
}
 
int main()
{
    double nbre_fabs, nbre_ceil, nbre_floor;
 
    printf("\n Entre un nombre négatif décimal : \n");
    scanf("%lf",&nbre_fabs);
 
    printf("\n La valeur absolue de %.3f est %.3f \n", nbre_fabs, fabs(nbre_fabs));
 
    printf("\n Entre un nombre décimal : \n");
    scanf("%lf",&nbre_ceil);
 
    printf("\n L'arrondi à l'entier supérieur de %.3f est %.3f \n", nbre_ceil, ceil(nbre_ceil));
 
    printf("\n Entre un nombre décimal : \n");
    scanf("%lf",&nbre_floor);
 
    printf("\n L'arrondi à l'entier inférieur de %.3f est %.3f \n", nbre_floor, floor(nbre_floor));
 
    return 0;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
double f(double nbre)
{
    return fabs(nbre);
}
double c(double nbre)
{
    return ceil(nbre);
}
double fl(double nbre)
{
    return floor(nbre);
}
 
int main()
{
    double nbre;
 
    printf("\n Entre un nombre négatif décimal : \n");
    scanf("%lf",&nbre);
 
    printf("\n La valeur absolue de %.3f est %.3f \n", nbre, fabs(nbre));
 
    printf("\n L'arrondi à l'entier supérieur de %.3f est %.3f \n", nbre, ceil(nbre));
 
    printf("\n L'arrondi à l'entier inférieur de %.3f est %.3f \n", nbre, floor(nbre));
 
    return 0;
}

31/05/2019, 12h13
Sve@r

Citation:

Envoyé par nl.smart

ok, et maintenant les 2 codes suivants fonctionnent en ayant bien entendu tenu compte de vos explications, encore merci à vous, c'est donc résolu :-)

Moui... mais pourquoi écrire des fonctions qui ne font rien d'autre que d'appeler d'autres fonctions ?
Généralement, quand on écrit une fonction, c'est pour apporter une plus value à ce qui existe. Là tu as (par exemple) "f()" qui appelle "fabs()" et rien de plus. Question plus value...:aie:

Citation:

Envoyé par nl.smart

dalfab évoquait lui aussi le fait que je nomme une fonction déjà présente dans la bibliothèque mathématique, pour aboutir au plantage du code.

En fait le "UB" c'est beaucoup plus vicieux car c'est un comportement "imprévisible". Tu ne peux donc même pas dire "le code va planter" car c'est déjà là faire une prédiction de comportement. "imprévisible" ça va du "tout semble fonctionner correctement" (c'est ce qui s'est passé chez-moi quand j'ai exécuté ton second code) jusqu'à "le programme reformate ton disque dur et arrête ton ordi" (cas extrème mais pourquoi pas... 8-))
31/05/2019, 13h45
nl.smart

Le mot de la fin aura été pour vous, encore merci, sûrement à bientôt, l’apprentissage continue !