Adding large numbers in C

Question

I am a bit confused about the behavior of c when it comes to adding large numbers. This is probably a beginner's question but would appreciate any help.

unsigned long total = 0;
total = 1124073472 + 2835349503;
total += 2533359615;
printf("Total: %u\n", total);

The total which gets printed above is not correct. The first add result is fine but the third add throws the total off. I am thinking it is because of overflow. My question is what is a possible solution? Is there a solution without using third party libraries?

Note: I have tried various data types for total. Some of them are DWORD64, INT64, LONG64 etc.

Thanks in Advance.

If `unsigned long` isn't wide enough, `unsigned long long` is the next choice. — Bo Persson, Mar 28 '11 at 17:35
@fazo You haven't established that the datatype is too small. On a system with 32 bit ints and 64 bit longs, AndyPerfect's comment both explains the wrong result and corrects it. — Jim Balter, Mar 28 '11 at 21:18
@Jim Balter - he said nothing about 32i/64l machine. If it's 32i/32l machine he's competely wrong — fazo, Mar 28 '11 at 21:43

score 3 · Answer 1 · answered Mar 28 '11 at 17:40

The mathematical sum of these three numbers is larger than 2³², and you're using unsigned long, which is 32 bits wide on Windows (even if you compile your program with 64 bit pointers -- this is a willful violation of C89 on Microsoft's part), so the C and C++ standards specify that it wraps around. The number you get is 1124073472 + 2835349503 + 2533359615 - 2³².

If you use a 64-bit type, you have to change the printf format specifier to match. This code will give the mathematically expected answer on a C99-compliant system:

#include <stdio.h>

int main(void)
{
    unsigned long long total = 1124073472 + 2835349503;
    total += 2533359615;
    printf("Total: %llu\n", total);
    return 0;
}

No version of MSVC is C99-compliant, however. I don't know the appropriate type declaration or printf format specifier for MSVC.

Addenda: 1) Addition is not specified to wrap around on overflow for signed types; it's undefined behavior. This most commonly bites people who use signed loop indices when the loop limit is data-dependent. 2) If you were doing math with numbers that could potentially be bigger than 2⁶⁴, even long long would not save you. C and (as far as I know) C++ do not have true "bignum" types; you'll need a third party library.

No, but there *was* an explicit requirement that `size_t` was no larger than `unsigned long`, and an implicit requirement that `void *` could be cast to `size_t` (and therefore also `unsigned long`) and back without loss of information. Microsoft browbeat the C committee into relaxing both these requirements in the C99 revision, even though that licenses ABIs that break a lot of legacy code, and even though, as far as this external observer has been able to tell, Microsoft has never had any interest in actually making its implementation conform to C99. — zwol, Dec 11 '11 at 18:47

score 2 · Accepted Answer · answered Mar 28 '11 at 17:34

2

You're correct, it's because of overflow. Using a 64-bit type will fix it - you will need to change your printf() format string to printa 64-bit type too, though. Making total an unsigned long long will probably get you a 64-bit type, but the safest way would be to use one of the typedefs from stdint.h. Here's an example program - I also used inttypes.h to get PRIu64.

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(int argc, char **argv)
{
  uint64_t total = 0;
  total = 1124073472 + 2835349503;
  total += 2533359615;
  printf("Total: %"PRIu64"\n", total);

  return 0;
}

answered Mar 28 '11 at 17:34

Carl Norum

219,201
40
422
469

@Goz, thanks - I didn't see the [visual-c++] tag. I wrote my answer with C99 features, too - I expect that won't work with Microsoft's tools either. I'll leave the answer here in case somebody gets here looking for a C solution - the question is tagged with [c], as well. – Carl Norum Mar 28 '11 at 17:42
Visual C++ supports %llu just fine, along with everything else related to the "long long int" type. – librik Mar 30 '11 at 00:06

score 1 · Answer 3 · answered Dec 11 '11 at 17:49

1

Well almost(!) everyone is right at there point. I think you can look @ following two page as well. It will really give you some better idea about how you can handle a really BIG numbers :

answered Dec 11 '11 at 17:49

enam

1,179
1
10
24

This is the real solution. Thumbs up! – Qiang Xu Oct 19 '12 at 17:42
Thanks! Very glad to know it helps you :) @Qiang Xu – enam Oct 20 '12 at 08:24

score 0 · Answer 4 · answered Mar 28 '11 at 17:35

What you are seeing is indeed because of an overflow but in the print type as others have mentioned since that number fits inside a long.

You will be able to do operations that fit within the long data type. If you want to go larger than that you'd need some sort of "Big Integer" function and if you do not want to use a third party library you can implement your own, however you'd be reinventing the wheel and are better off with using a tested library.

score 0 · Answer 5 · answered Mar 28 '11 at 17:37

Have you tried "unsigned long long int"? This will certainly be 64 bits, or use uint64_t, if you have stdint.h. Of course, you could run into new overflow problems (it indeed is that) when you choose even larger numbers, and then it's time to use a bignum library like gmp. And do an overflow check before adding, if you do stick with 64 bit numbers. And use "%lld" to print the decimal result in that case.

score 0 · Answer 6 · edited May 23 '17 at 11:55

It is indeed an overflow. You will probably want to create your own "BigNumber" class to perform arithmetic on arbitrarily large numbers. However, I'd recommend using a library if possible. Writing your own "BigNumber" class can be a bit of a chore. Check out the ones posted here - Class for calculating arbitrarily large numbers?

If you don't use them, you can at least use them as guidance.

Goz · Answer 7 · 2011-03-28T17:45:44.113

0

The following code ought to work under Visual C++:

unsigned __int64 total = 0;
total = 1124073472LL + 2835349503LL;
total += 2533359615LL;
printf("Total: %I64u\n", total);

edited Mar 28 '11 at 17:45

answered Mar 28 '11 at 17:37

Goz

61,365
24
124
204

Unless something's wrong with the compiler, `LL`'s shouldn't be necessary. – Alexey Frunze Dec 11 '11 at 18:21

score 0 · Answer 8 · answered Mar 28 '11 at 17:45

The code has two problems:

The unsigned long has only 32 bit in 32 bit systems. You need to use long long (and turn on the C99 standar in the compiler settings), or INT64 or something like that.
The %u in the printf format string is for 32 (or less) bit wide numbers. You need to use %llu instead.

score 0 · Answer 9 · answered Mar 28 '11 at 21:23

Your code is buggy. You should replace %u with %lu in your printf statement to match the type of total. That is sufficient if you're on a system with 32 bit ints and 64 bit longs. But if you're using some other sort of system, you may need to use unsigned long long as noted in some of the other answers.

Adding large numbers in C

9 Answers9