To calculate power of a number using call by reference

Question

#include <stdio.h>

void power(int *x,int *y);
 
int main()

{

    int m,n;
    printf("Enter the number and power :-");
    scanf("%d%d",&m,&n);
    power(&m,&n);
    
}

void power(int* x, int* y)

{

    int i,result=1;
    if(*y==0)
        printf("The result = 1");
    else
    {
        for(i=0; i<*y; i++)
        {
            result *= (*x);
        }
        printf("The result of %d^%d = %d",*x,*y,result);
    }
}

The result of 10^10 comes out to be 1410065408 I don't know what am I doing wrong

Have you tried running your code line by line in a debugger while monitoring the values of all variables? If not, then you may want to read this: [What is a debugger and how can it help me diagnose problems?](https://stackoverflow.com/q/25385173/12149471) You may also want to read this: [How to debug small programs](https://ericlippert.com/2014/03/05/how-to-debug-small-programs/) — Andreas Wenzel, Aug 13 '20 at 18:17
you have an overflow, replace `int` by `long long` or `int64_t` to be sure and you will have the right result — bruno, Aug 13 '20 at 18:18
On most platforms, [`INT_MAX`](https://en.cppreference.com/w/c/types/limits) is defined as 2.1 billion, which is 9 decimal places. This means that an `int` can represent a number between `-2,147,483,648` and `+2,147,483,647`. The result of your mathematical operation falls outside that range. — Andreas Wenzel, Aug 13 '20 at 18:22
Ignoring UB from overflow ... `(10*10*10*10*10*10*10*10*10*10) % (2^32) = 1410065408` ==> `10^10 = 2*4294967296 + 1410065408` — pmg, Aug 13 '20 at 18:23

score 2 · Answer 1 · answered Aug 13 '20 at 18:21

you visibly have an overflow, probably your intare on 32bits

using long long :

#include <stdio.h>

void power(long long *x,long long *y);
 
int main()

{

    long long m,n;
    printf("Enter the number and power :-");
    scanf("%lld%lld",&m,&n);
    power(&m,&n);
    
}

void power(long long* x, long long* y)

{

    long long i,result=1;
    if(*y==0)
        printf("The result = 1");
    else
    {
        for(i=0; i<*y; i++)
        {
            result *= (*x);
        }
        printf("The result of %lld^%lld = %lld",*x,*y,result);
    }
}

Compilation and execution:

pi@raspberrypi:/tmp $ gcc -Wall p.c
pi@raspberrypi:/tmp $ ./a.out
Enter the number and power :-10 10
The result of 10^10 = 10000000000pi@raspberrypi:/tmp $

To be sure to use 64b int you can use int64_t

I guess you don't need to use `long long` to pass the base & the power. Using an integer here will be memory saving. — Rohan Bari, Aug 13 '20 at 18:34
@RohanBari I admit I did a lazy global change, anyway the OP using big numbers the base can need a long long already without producing overflow because power enough small, and why not having the base 0 and a power requiring a long long too ? :-) — bruno, Aug 13 '20 at 18:36

score 1 · Answer 2 · answered Aug 13 '20 at 18:23

1

You're using int for the result, and it doesn't fit. You need to use long. The size of int is 32 bits which has a max signed value of 2147483647.

answered Aug 13 '20 at 18:23

rallen911

148
9

4

Yes, but `long` might be 32 bits too: use `long long`. – Weather Vane Aug 13 '20 at 18:24
@WeatherVane is correct. For example, on the Microsoft Windows platform, a `long` is 32 bits, not 64. – Andreas Wenzel Aug 13 '20 at 18:25
32 bits is the *minimum* guaranteed size of `long`. – Weather Vane Aug 13 '20 at 18:26
1

Thanks! I wish it were a 930! It's a 1986 Carrera with the 3.2L. – rallen911 Aug 18 '20 at 17:04
@rallen911 ah, a turbo look then ;-) – bruno Aug 19 '20 at 14:50

Rohan Bari · Answer 3 · 2020-08-13T18:38:33.497

Your given program uses 4-bytes integer which is capable to hold the values between -2,147,483,648 to 2,147,483,647 but 10^10 is too large to hold it.

Taking the appropriate type (such as long long) to hold such large outcome will easily solve your issue (notice the comments as an explanation to the code):

#include <stdio.h>

// The function signature
void power(int *x, int *y);

int main(void) {
    int bs, pw;
    
    printf("Enter the value of base and power: ");

    // Verifying the inputs
    if (scanf("%d%d", &bs, &pw) != 2)
        // If the values were incorrectly entered, then it returns
        // with an error code without further actions
        return 1;
        
    power(&bs, &pw);
    
    return 0;
}

// The function definition    
void power(int *x, int *y) {
    long long result = 1;

    // Dereferencing and using assignment operator for self-multiplication with
    // the dereferenced 'x'
    for (int i = 0; i < *y; i++)
        result *= *x;
    
    printf("Results: %lld\n", result);
}

A sample test case:

Enter the value of base and power: 10 10
Results: 10000000000

Works on OnlineGDB as well.

To calculate power of a number using call by reference

3 Answers3