Create a function that return the pow b^e

Question

I have to create a function that return the value of b^e. This is what I have done:

#include<stdio.h>
#include<math.h>

int funzione_potenza (int b, int e);

int main ()
{
    int b, e, potenza;

    printf("Inserisci la base: ");
    scanf("%d",&b);

    printf("Inserisci l'esponente: ");
    scanf("%d",&e);

    printf("La potenza e' %d",potenza);

    return 0;
}

int funzione_potenza (int b, int e)
{
    int potenza;

    potenza = pow(b,e);

    return potenza;
}

When i run it, it displays a false value of the power (ex. 5343123) What is wrong?

Answer 1

You don't need a function to invoke the inbuilt pow function. If you are trying to write a function of your own, try to build a solution with loop or recursion.

Answer 2

Assuming you are free to use math library, the method will return correct answer unless the number fits in "int". Otherwise, consider using "long long int" for larger numbers.

In case you are not allowed to use math library, here is a correct implementation:

long long int power(int b, int e){
          if(e==0){
                 return 1;
           }
           else if(e%2==1){
                 long long int temp = power(b,e/2);
                 return temp*temp*b;
           }
           else{
                 long long int temp = power(b,e/2);
                 return temp*temp;
           }
 }

Answer 3

There are two issues:

First of all you're getting a garbage value because you never call the funzione_potenza function.

int main()
{
  int b, e, potenza;

  printf("Inserisci la base: ");
  scanf("%d", &b);

  printf("Inserisci l'esponente: ");
  scanf("%d", &e);

  potenza = funzione_potenza(b, e);       // <<<<<<<<<< insert this line

  printf("La potenza e' %d", potenza);

  return 0;
}

Secondly you don't even need the funzione_potenza which is just a wrapper around pow, you can call pow directly:

...
scanf("%d", &e);

potenza = pow(b, e);

printf("La potenza e' %d", potenza);
...

Answer 4

you can implement power function without using "pow"usage of "pow"-function the built-in function as well below is the code.

#include <stdio.h>

//function prototype
int funzione_potenza (int b, int e);

int main ()
{
  int b, e, potenza;

  printf("Inserisci la base: ");
  scanf("%d",&b);

  printf("Inserisci l'esponente: ");
  scanf("%d",&e);

  potenza = funzione_potenza (b,e);

  printf("La potenza e' %d",potenza);

  return 0;
 }

 int funzione_potenza (int b, int e)
 {
    //local variables
    int i, potenza = b; //initialize potenza with b

    for (i = 0; i < e; i++ )
    {
       potenza = potenza * e; //multiply n-number of times to get the power
    } 

    return potenza;
 }

Answer 5

My intention was to show the way you can realize that but that's basically reinventing the wheel so not recommended. Here I have shown the rough idea of how you can try to write a power function.

Alternative way to realize that would be

int mpow(int b, int e) {
    if (e <= -1) {
        fprintf(stderr, "mpow:(b: integer, e:non-negative integer )");
        exit(1);
    }
    if (e == 0) return 1;
    if (b == 0) return 0;
    int ans = 1;
    for (int i = 1; i <= e; i++) {
        if (!checkIfOverflown(ans, b)) ans = ans * b;
        else {
            fprintf(stderr, "%s\n", "overflow in multiplication");
            exit(1);
        }

    }
    return ans;

}

As pow returns double you shouldn't cast it to integer( why do you want to lose precision).

And why wrap pow in function? You can use it directly.

Is my function correct?

This function is correct as long as the integer doesn't mess it up by spilling up things. For small value of b,e it works.

Also a simple more effective way to do this will be

int mpow(int b, int e) {
    int res = 1, flag = 0;
    if (e <= -1) {
        fprintf(stderr, "mpow:(b: integer, e:non-negative integer )");
        exit(1);
    }
    while (e > 0) {
        if (e % 2 == 1) {
            if (!checkIfOverflown(res, b))
                res = (res * b);
            else {
                flag = 1;
                break;
            }
        }
        if (!checkIfOverflown(b, b))
            b = (b * b);
        else {
            flag = 1;
            break;
        }
        e /= 2;
    }
    if( flag ){
        fprintf(stderr, "%s\n", "overflow in multiplication");
        exit(1);
    }
    return res;
}