Return ne renvoie rien

DARsKater Messages postés 873 Statut Membre -  
Revan26914 Messages postés 1821 Statut Contributeur -
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

  1. Revan26914 Messages postés 1821 Statut Contributeur 320
     
    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
    1. [Dal] Messages postés 6122 Date d'inscription   Statut Contributeur Dernière intervention   1 108
       
      et
      nb *= nb;
      est faux également.


      Dal
      0
    2. Revan26914 Messages postés 1821 Statut Contributeur 320
       
      Non, c'est correct. Ca équivaut à nb = nb * nb;
      0
    3. fiddy Messages postés 441 Date d'inscription   Statut Contributeur Dernière intervention   1 847
       
      @Revan26914,
      Syntaxiquement, oui c'est juste. Mais fonctionnellement c'est faux.
      Il faudrait plutôt : nb *= power;
      0
    4. [Dal] Messages postés 6122 Date d'inscription   Statut Contributeur Dernière intervention   1 108
       
      @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
    5. fiddy Messages postés 441 Date d'inscription   Statut Contributeur Dernière intervention   1 847
       
      Erf... A vouloir répondre trop vite...
      Tu as bien évidemment raison :-).
      0
  2. sambia39 Messages postés 610 Date d'inscription   Statut Membre Dernière intervention   50
     
    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
    1. Revan26914 Messages postés 1821 Statut Contributeur 320
       
      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
    2. fiddy Messages postés 441 Date d'inscription   Statut Contributeur Dernière intervention   1 847
       
      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
    3. [Dal] Messages postés 6122 Date d'inscription   Statut Contributeur Dernière intervention   1 108
       
      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
    4. sambia39 Messages postés 610 Date d'inscription   Statut Membre Dernière intervention   50
       
      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
    5. [Dal] Messages postés 6122 Date d'inscription   Statut Contributeur Dernière intervention   1 108
       
      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