why pointer variable not showing 100 digits?

Question

aim: i had a requirement for accuracy i need 100 digits to be displayed or atleast 50 digits

try 1: first i had used integer variable then it displayed only 10 digits

try 2: with the help of my friend i used pointers concept it successfully had input 50 to 100 digits but pointer variable display only 10 digits

the program i had written was

#include <stdio.h>
#include <string.h>

main() 
 {
    int *p;
    p=(int*)malloc(100*sizeof(int));
    *p=1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890;
    printf("%d",*p); 
 }

on executing the above procedure i'm getting a garbage value

thanks in advance

Answer 1

You need to use a bignum (arbitrary precision big numbers) library, since native int or long have a precision limited by the C implementation - ie the hardware (often 32 or 64 bits; see also <stdint.h> header and int32_t & int64_t types). I suggest using GMPlib; you need to be fluent in C to use such libraries. Read documentation of GMLib.

^{Don't try to code bignumber arithmetic yourself. You'll use inefficient algorithms. Efficient algorithms for bignums are difficult to understand and to invent. You can still get a PhD on that. So use some existing bignum library.}

So you might code something like the following to multiply your bignum by 137 and print the result

mpz_t bign;
mpz_t bigr;
// initialize bign from a literal string
mpz_init_set_str (bign,
                 "12345678901234567890123456789012345678901234567890"
                 "12345678901234567890123456789012345678901234567890",
                 10);
// initialize bigr
mpz_init(bigr);
/// compute bigr = bign * 137 (137 is a long, not a bignum)
mpz_mul_si(bigr, bign, 137L);
/// print bigr on stdout in base 10
mpz_out_str (stdout, 10, bigr);
/// clear all the numbers
mpz_clear(bign);
mpz_clear(bigr);

On a Linux system with GMP installed, you could compile such a code (in yoursource.c) using:

gcc -Wall -Wextra -g yoursource.c -lgmp -o yourprog

On other systems you might need some -I and -L arguments to gcc. When you have debugged your program, ask the compiler to optimize it with -O2

Notice that some languages (Common Lisp, Scheme, Python) have built-in bignums.

BTW, your main function is incorrectly defined. It should be defined as int main(int argc, char**argv) ...

Answer 2

To answer the first part, a single signed integer (assuming 32 bits) can take values between -2,147,483,648 and +2,147,483,647

This is where your ten digits comes from.

Depending on your compiler, you may have unsigned long long available (64 bits) but that still only offers you a maximum or 0..18,446,744,073,709,551,615 (20 digits)

To handle 100-digit numbers will require some jiggery-pokery!

Answer 3

You can't store such a long digit in an int variable or a pointer which is pointing to type int.

If int is of 32 bit, the range is [−2147483647,+2147483647]. C data types

To store the large value you can use a char pointer and initialized it with the string constant.

For example:

---

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

main() 
{
    char *p = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
    printf("%s\n",p); 
}

Answer 4

int * p = malloc(100*sizeof(int));

Allocates memory for an array of 100 int.

*p= ....

In fact is the same as

p[0]=...

So this

*p=1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890;

assigns to an int.

An int may hold not more then a 32 bits (less on some platforms). The largest 32bit (positive) integer is 2147483647.

Answer 5

C is a language close to the hardware. So you need to understand the storage capabilities and limitations of its data types.

An int on a PC is only able to store 32 bit or 64 bit values, depending on your hardware and OS version.

Yes, you can implement routines for handling larger value, and using a linked list of digits is one way do it.