I’ve recently started learning C++.
Now I was just making a joke with my friend that:
<blockquote>
Mr David is so rich that if we had 1 Dollar and we doubled it a billion times, it still wouldn’t be enough…
</blockquote>
Now, I got a bit curious that how much would that be EXACTLY. I’ve got 32 gb of ram, I mean let’s compute that.
Using my newfound knowledge of the C++ language I wrote the following script:
<pre><code>#include &lt;iostream&gt;
using namespace std;

int main(){
 unsigned long long int start_val = 1;
 for (int i=0; i&lt;=1000000000; i++){start_val += start_val;}
 cout &lt;&lt; &quot;Mr David&#x27;s Income is: &quot; &lt;&lt; start_val &lt;&lt; endl;
 return 0;
}

</code></pre>
Now the program compiled and executed and I got my answer in less than 2 seconds…
<blockquote>
Mr David’s Income is: 0
</blockquote>
WHAT??
I was confused… I knew the number WOULD be big but why was it 0?
The only possible way was that the register had been overflowed resulting in my current situation.
I tried looking for solutions to this online, I didn’t understand them…
So, I come to the dev community to ask HOW THE HELL am I supposed to store such a big number?
And why doesn’t the <code>unsigned long long int</code> not work? How much space in memory does <code>long long int</code> provide in the first place?
And how can I get my answer to this VERY IMPORTANT question?

This is the place to discuss everything about C/C++ and Assembly —from basic programming concepts to advanced topics like memory management, concurrency, and performance optimization. Share knowledge, ask questions, and collaborate with developers.

C/C++ Community

A beginner learning C++ tried to compute a large number by doubling a value repeatedly but encountered an integer overflow issue, which caused an incorrect result. The post seeks advice from the developer community on how to store and compute extremely large values in C++, as the standard 'unsigned long long int' data type was insufficient to handle the computation.

C++ Help

OMG I IDID IT!!!
Well well well, look who came out on top.
Have to give a big thanks to Python for helping me find the truth.
The calculations were infact right. Here is the code used.
<pre><code>import sys
sys.set_int_max_str_digits(1_000_000_001)

with open(&quot;income.txt&quot;, &#x27;+a&#x27;) as file:
 file.write(2**(10**9))

print(&quot;Income Found&quot;)
</code></pre>
Now here are some details
<blockquote>
The file size was as calculated (almost): 287 MB
The length of the answer (according to Notepad++): 301,029,996
The first digit is: 4
The last digit is: undefined, yeah… it couldn’t load
</blockquote>
I’m quite happy with the results tbh :)
Thanks to everyone who replied to my stupid query.
Till next time ig.

To represent a number like the one you mention you need to figure out how many digits it takes. Since it’s base 2, you’ll need 1,000,000 bits. No datatype in C++ will hold that many bits. (The number of decimal digits is log(2^100000)=301,300 (plus one actually).
As an exercise to see how far you got, you might try printing all the values as they’re computed and stop iterating when it rolls around to 0.
To get the answer you want, you might try the The GNU Multiple Precision Arithmetic Library (GMP). <a href="https://gmplib.org/" target="_blank" rel="noopener nofollow">https://gmplib.org/</a>
From their website:
GMP is a free library for arbitrary precision arithmetic, operating on signed integers, rational numbers, and floating-point numbers. There is no practical limit to the precision except the ones implied by the available memory in the machine GMP runs on. GMP has a rich set of functions, and the functions have a regular interface.

You overflow the <code>start_val</code> variable. You should use a datatype that is big enough to hold the result, although I doubt it exists. Maybe a <code>__uint128_t</code> (if you’re using GCC). You could also write it yourself, but that might be a bit difficult.

In binary doubling a number means shifting the bits to the left. Eg.
The number 1 in a <code>uint8_t</code> would be: <code>0000 0001</code>. To double that once to 2 you get: <code>0000 0010</code> and doubling to 4 makes <code>0000 0100</code> and so forth.
If you consider your puzzle. You need to double a billion times for which you will need a billion + one bits as you will shift your 1 bit to the left a billion times.
The biggest type available int C/C++ is <code>uint128_t</code> (might be restricted based on the compiler) and since <code>128 &lt; 1,000,000,000</code> that won’t work with a simple type.

What even is this code? All jokes aside the variable overflowed and it reset to 0. You can’t have infinite numbers on a computer