Comment générer un produit flottant de multiplicateurs int?

Question

J'essaie de calculer l'exposant d'un nombre. Quand je fais tout en int j'obtiens le résultat correct, mais la sortie doit être flottante, quand j'essaye de convertir avec f dans printf() j'obtiens 0, quand j'utilise% d j'obtiens le bon résultat. Je ne peux pas modifier la partie main() du programme, je ne peux modifier la fonction * powerArgs(). L'entrée du programme est 3, 5.

Divulgation complète, cela fait partie d'une tâche scolaire. Je ne demande pas de code complet. J'apprécierais une réponse plus générale me montrant ce que j'oublie, peut-être quel domaine je devrais étudier plus pour trouver la réponse moi-même.

#include <stdio.h> 
#include <stdlib.h> 

int *powerArgs(int *pA, int *pB); 

/* MAIN */ 
int main(int argc, char **argv) 
{ 

    if (argc != 3) 
    { 
     printf("?Invalid number of arguments\n"); 
     system("pause"); 
     exit(1); 
    } 

    int parmA = atoi(argv[1]); 
    int parmB = atoi(argv[2]); 
    int idx; 

/* Part C: Raise parmA to the power of parmB. Return pointer to the result */  
/*   Reset the original values after we print the result */ 
    printf("%d raised to the %d power is %0.1f\n", parmA, parmB, *powerArgs(&parmA, &parmB)); 

    printf("\n"); 

    system("pause"); 
    exit(0); 
} 

int *powerArgs(int *pA, int *pB) 
{ 
     int idx, result = *pA; 

     for (idx = 1; idx < *pB; idx++) 
     { 
      result *= *pA; 
     } 

     return &result; 
}  

Answer 1

float et int convertir automatiquement en C - vous pouvez affecter l'un à l'autre, et la seule chose à surveiller est que si vous attribuez un trop grand flotteur à un int, alors vous obtenez un comportement non défini (ou p ossible un résultat non spécifié, j'oublie. De toute façon ce n'est pas bon).

Ainsi, votre fonction powerArgs peut être juste:

float powerArgs(float a, int b) { 
    // do some stuff and return a value 
} 

Ensuite, vous pouvez l'appeler comme powerArgs(parmA, parmB), même si parmA est un entier.

Edit: si vous ne pouvez pas modifier les paramètres d'appel, vous pouvez le faire à la place

float powerArgs(int *a, int *b) { 
    float base = *a; 
    int exponent = *b; 
    ... 
} 

Si votre professeur vous a vraiment donné le code où la fonction est appelée *powerArgs(int *a, int *b), votre professeur est une menace . Il n'y a aucune raison terrestre pour laquelle une fonction d'exponentiation devrait retourner un pointeur à un flottant. Il y a une solution laide, vous pouvez utiliser:

float *powerArgs(int *a, int *b) { 
    static float result; 
    ... 
    result = /* the result of the calculation */; 
    return &result; 
} 

Le problème est, tous les appels à powerArgs partagent le même objet result. static l'empêche de cesser d'exister à la fin de l'appel, mais le partage introduira des problèmes à long terme. Il est bon de faire cela, mais c'est peut-être la meilleure solution au problème que vous avez réglé.

solution C Sneaky:

struct FloatWrapper { 
    float value; 
    float operator*() { 
     return value; 
    } 
    FloatWrapper(float f) : value(f) {} 
}; 

FloatWrapper powerArgs(int *a, int *b) { 
    ... 
    float result = /* whatever */; 
    ... 
    return result; 
} 

Cela retourne un objet de classe FloatWrapper, en valeur, et FloatWrapper surcharge l'opérateur *. Cela signifie que *powerArgs(...) évalue le flottant que la fonction aurait dû renvoyer par valeur en premier lieu, sans nécessitant un pointeur vers un emplacement de stockage spécial.

Par ailleurs, vous pouvez vérifier ce que votre fonction fait quand parmB est 0.

Answer 2

D'abord, votre int *powerArgs(int *pA, int *pB) fonction retourne l'adresse d'une variable locale, qui se traduit par un comportement non défini. Utilisez les éléments suivants à la place:

int powerArgs(int *pA, int *pB) 
{ 
    int idx, result = *pA; 

    for (idx = 1; idx < *pB; idx++) 
    { 
     result *= *pA; 
    } 

    return result; 
} 

Ensuite, si vous voulez convertir en float, vous ne devriez pas le faire dans l'appel à printf(), mais plutôt convertir la valeur en floatavant l'appel comme ceci:

printf("%d raised to the %d power is %0.1f\n", parmA, parmB, (float)powerArgs(&parmA, &parmB)); 

Answer 3

Lorsqu'une fonction se termine, toutes ses variables locales cessent d'exister (et leurs adresses pointent vers des déchets). Pour faire plaisir à votre professeur qui a créé cette interface très délicate, vous devez trouver un moyen de garder un objet en vie après que la fonction existe.

Vous avez, au moins, 3 options:
a) la réutilisation un des paramètres d'entrée
b) utiliser une variable globale
c) utiliser une variable statique

l'option

a)

int *powerArgs(int *pA, int *pB) { 
    /* calculate */ 
    *pA = CALCULATED_VALUE; 
    return pA; 
} 

l'option b)

int global_power; 

int *powerArgs(int *pA, int *pB) { 
    /* calculate */ 
    global_power = CALCULATED_VALUE; 
    return &global_power; 
} 

o ption c)

int *powerArgs(int *pA, int *pB) { 
    static int static_power; 
    /* calculate */ 
    static_power = CALCULATED_VALUE; 
    return &static_power; 
} 

Aucune de ces "solutions" n'est bonne; le moins mauvais est l'option c)