Return ne renvoie rien

Fermé
DARsKater Messages postés 747 Date d'inscription vendredi 4 janvier 2008 Statut Membre Dernière intervention 5 août 2020 - Modifié par DARsKater le 9/07/2014 à 23:12
Revan26914 Messages postés 1778 Date d'inscription dimanche 14 octobre 2007 Statut Contributeur Dernière intervention 15 octobre 2019 - 10 juil. 2014 à 13:26
Bonjour, j'essaye de calculer une puissance, je pense que mon code est bon, mais pourtant il ne renvoie rien !

Voici le dit code :

int ft_iterative_power(int nb, int power)
{
int p;
p = 0;
if (power == 0)
return(1);
else if (power < 0)
return(0);
else
{
while (p != power)
{
nb *= nb;
p++;
}
return(nb);
}
}

int main(void)
{
ft_iterative_power(5, 2);
return(0);
}

Je compile avec "gcc -Wall -Wextra -Werror -o" si ca joue un role, et je n'ai pas l'option de changer de maniere pour compiler.

Un gros merci d'avance pour votre aide!



c:\>

2 réponses

Revan26914 Messages postés 1778 Date d'inscription dimanche 14 octobre 2007 Statut Contributeur Dernière intervention 15 octobre 2019 320
10 juil. 2014 à 00:07
Bonsoir,

Ta fonction retourne bien un résultat. Si tu ne le vois, c'est parce que tu ne l'affiches nulle part ;)


#include <stdio.h>

int ft_iterative_power(int nb, int power)
{
int p = 1;

if (power == 0)
return(1);
else if (power < 0)
return(0);
else
{
while (p != power)
{
nb *= nb;
p++;
}
return(nb);
}
}

int main(void)
{
printf("%d\n", ft_iterative_power(5, 2));
return(0);
}


Par ailleurs, il y a une petite erreur dans ton code: il faut faire commencer p à 1.
0
[Dal] Messages postés 6174 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 2 février 2024 1 083
10 juil. 2014 à 00:27
et
nb *= nb;
est faux également.


Dal
0
Revan26914 Messages postés 1778 Date d'inscription dimanche 14 octobre 2007 Statut Contributeur Dernière intervention 15 octobre 2019 320
10 juil. 2014 à 00:55
Non, c'est correct. Ca équivaut à nb = nb * nb;
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 835
10 juil. 2014 à 09:34
@Revan26914,
Syntaxiquement, oui c'est juste. Mais fonctionnellement c'est faux.
Il faudrait plutôt : nb *= power;
0
[Dal] Messages postés 6174 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 2 février 2024 1 083
10 juil. 2014 à 10:18
@fiddy : je ne pense pas que
nb *= power
fasse l'affaire, cela fait autre chose : multiplier à chaque itération le résultat par ce qui est sensé être l'exposant, ainsi pour 5 ^3, on aurait :

5
5 * 3 = 15
15 * 3 = 45

ce qui n'est pas non plus la fonction exponentielle.

je passerai plutôt par une variable additionnelle contenant le résultat, sachant qu'on a besoin de conserver la valeur de nb, pour effectuer les multiplications successives, et qu'il ne faut donc pas l'écraser.

du code plus bas, là : https://forums.commentcamarche.net/forum/affich-30482877-return-ne-renvoie-rien#9


Dal
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 835
10 juil. 2014 à 10:39
Erf... A vouloir répondre trop vite...
Tu as bien évidemment raison :-).
0
sambia39 Messages postés 610 Date d'inscription vendredi 31 juillet 2009 Statut Membre Dernière intervention 9 février 2023 49
10 juil. 2014 à 01:54
Bonsoir
Juste une remarque corrigé moi si je me trompe, sa fonction est bien une fonction de puissance ? si oui elle ne peut pas marcher pourquoi parce que
 0^0 = 1 et non 0
enfin de ce qui est resté de mes mathématiques de plus
@Dal l'instruction
 nb*= nb 
est correcte sauf que c'est l'ensemble de son algorithme qui est fausse .
Pour mieux comprendre voici un exemple
#include <stdio.h>

/***
*	fonction puissance en itérative
*	écrit par @DARsKater
***/
int ft_iterative_power(int nb, int power){
    
    int p;
    /***
    *	& même en remplaçant p = 0
    *	par p = 1 ne change rien 
    *	algorithme est fausse
    ***/ 
    p = 1;				
    
   	if( power == 0 )
   		return ( 1 );
   	
  else if( power <= 0)
        return( 1 );
        
   else{
        while( (p != power) ){
     		nb *=nb;
            p++;
 		}
 		return( nb );
    }
}


/***
*	fonction puissance en itérative
***/
unsigned int f_PowerIter(int iNb,int const pw){
	
	int i = 0;	
	int r = 1;
	
	if( pw <= (0) )
		return ( r );
	else{
		/*	boucle	*/
		for( ; i < pw; i++)
			 r *= iNb;
	}
	return ( r );
}

/***
*	fonction récursive puissance
***/
unsigned int f_PowerRecur(int iNb,int const pw){
	
	return ( (pw<=0) ? 1 : ( iNb *f_PowerRecur( iNb, pw-1 ) ) );
}

/***
*	fonction principale
***/
int main( void ){
	
		
	printf("@DARsKater\t= %d\n",ft_iterative_power(2, 10) );
	printf("@Sambia39 (1)\t= %d\n",f_PowerIter(2, 10) );
	printf("@Sambia39 (2)\t= %d\n",f_PowerRecur(2, 10) );
	return ( 0 );
}


à bientôt
0
Revan26914 Messages postés 1778 Date d'inscription dimanche 14 octobre 2007 Statut Contributeur Dernière intervention 15 octobre 2019 320
10 juil. 2014 à 02:22
Le premier test de sa fonction:


if( power == 0 )
return ( 1 );

Si la puissance est zéro, alors la fonction retourne 1.

Donc si tu veux évaluer ft_iterative_power(0, 0) il va rentrer dans la condition et retourner 1, ce qui est tout à fait correct puisque 0^0 = 1.

Bien que 0^0 = 1 soit controversé (certains le considère en effet comme non-défini), tous les langages de programmation ainsi que les calculettes le considèrent comme étant égal à 1.
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 835
10 juil. 2014 à 09:32
Disons plutôt que 0^0 est indéterminé et que par convention on on attribue 0^0 à 1. Mais dans certains cas, 0^0 est plus juste...
0
[Dal] Messages postés 6174 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 2 février 2024 1 083
10 juil. 2014 à 10:11
sambia39 :

@Dal l'instruction nb*= nb est correcte

ce que je veux dire, c'est que c'est là que se situe l'erreur produisant des résultats faux, car elle aboutit, à chaque itération, à mettre au carré la valeur de nb et c'est là précisément que l'algorithme est inexact. Ainsi, pour 5 ^ 3, même en mettant p à 1, on aura avec ce code :

5
5 * 5 = 25
25 * 25 = 625
ce qui n'est pas l'effet recherché

Ton code fonctionne bien.

Son code peut être corrigé avec quelques aménagements.

Sur la base de son code, moi, je ferai cela :

int ft_iterative_power(int nb, int power)
{
    int p;
    int result;

    p = 1;
    if (power == 0)
        return 1;
    if (power < 0) {
        fprintf(stderr, "Erreur : ft_iterative_power ne gère pas "
                "les exposants négatifs\n");
        exit(EXIT_FAILURE);
    }
    result = nb;
    while (p != power) {
        result *= nb;
        p++;
    }
    return result;
}


Dal
0
sambia39 Messages postés 610 Date d'inscription vendredi 31 juillet 2009 Statut Membre Dernière intervention 9 février 2023 49
Modifié par sambia39 le 10/07/2014 à 11:17
Bonjour
tu parles d'un cas dans le quelle la condition est véritablement égale à zéro et la seconde instruction ? elle ne sert pas à grand-chose
mais encore une fois, cela dépend du contexte mathématique.

Ce qui est sûr tout l'ensemble de son algorithme est mal conçu, si du coup 0^0 = 1 dans son programme, c'est normal qui nous donne la bonne réponse pareil si on met 10^2 = 100

mais dans plusieurs cas dont par exemple 2^10 = 1024 voir même 10^4 =10000 ça fonction nous renverra une valeur erroné exemple 2^4 = 255 dans certain cas c'est zéro directe qu'il nous envoie.


@DARsKater = 256
@Sambia39 (1) = 16
@Sambia39 (2) = 16

/!\ (de plus j'ai remarquer dans mon dernier poste à la ligne du code 20-21 j'ai oublier de mettre son 0)

à bientôt
0
[Dal] Messages postés 6174 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 2 février 2024 1 083
Modifié par [Dal] le 10/07/2014 à 10:44
sur la 2ème condition.. si on passe un nombre négatif :

https://fr.wikipedia.org/wiki/Puissance_d%27un_nombre#Puissance_.C3.A0_exposant_n.C3.A9gatif

il faudrait du code pour calculer cela et pouvoir renvoyer un nombre réel.

son code corrigé avec
p = 1;
mais en gardant
nb*= nb;
fonctionne avec les puissances de 2 et de 0 seulement. Si cela fonctionne avec les puissances de 2, c'est seulement parce que x ^ 2 ne comporte qu'une seule itération de mise au carré.


Dal
0