{"id":2461,"date":"2017-04-15T00:01:26","date_gmt":"2017-04-15T07:01:26","guid":{"rendered":"http:\/\/c-for-dummies.com\/blog\/?p=2461"},"modified":"2017-04-08T09:56:26","modified_gmt":"2017-04-08T16:56:26","slug":"surrender-to-the-overflow","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=2461","title":{"rendered":"Surrender to the Overflow"},"content":{"rendered":"

It’s a common question beginning programmers ask: “Why use different types of variables when every number can be expressed as a float<\/em>?”
\n
\nThe answer is, “efficiency.” It’s the same reason you write 1 instead of 1.000000 when you do math. A “1” is more compact, just as an integer occupies less space and is easier for the processor to manipulate than a real number.<\/p>\n

Back when storage space and processor speed were limited, real number calculations became a true burden on the computer. Early CPUs lacked math instructions, so a separate co-processor was required. And storage was tight, so if you could get by with a short int<\/em> value, you declared a variable as such.<\/p>\n

Today’s processors have advanced math instructions built-in, plus the computer has oodles of RAM. Still, it’s wise to use a float<\/em> or double<\/em> only when a fractional or large value is required. And with integer sizes, a long<\/em> holds more values than an short<\/em>, but it’s more efficient to use a short<\/em> when long<\/em>-size values aren’t required. The only problem you run into is when values overflow.<\/p>\n

As an example, the following code generates a Fibonacci sequence. It’s related to Exercise 9-16 in Beginning Programming with C For Dummies<\/em>. The LIMIT<\/code> value sets the length of the Fibonacci sequence:<\/p>\n

\r\n#include <stdio.h>\r\n\r\n#define LIMIT 10000\r\n\r\nint main()\r\n{\r\n    int fibo,nacci,count;\r\n\r\n    fibo=0;\r\n    nacci=1;\r\n    count=0;\r\n\r\n    do\r\n    {\r\n        printf(\"%d\\n\",fibo);\r\n        fibo+=nacci;\r\n        printf(\"%d\\n\",nacci);\r\n        nacci+=fibo;\r\n        count+=2;\r\n    } while( count < LIMIT );\r\n\r\n    return(0);\r\n}<\/pre>\n
When run, you see 10000 numbers in a Fibonacci sequence. On my terminal window, I see the sequence start like this:<\/p>\n
0\r\n1\r\n1\r\n2\r\n3\r\n5\r\n8<\/code><\/pre>\n
And on and on, until the end, which looks like this:<\/p>\n
1640003618\r\n-913691081\r\n726312537\r\n-187378544\r\n538933993\r\n351555449\r\n890489442<\/code><\/pre>\n
These are not values in a Fibonacci sequence. In fact, this output is the telltale sign of overflow: The program is running fine, but the variable width is unable to hold the huge value calculated. So the numbers are crazy, with negative values followed by positive values.<\/p>\n
To fix overflow, you must set the proper variable size. The range for an int<\/em> variable on my computer is between -2,147,483,648 and 2,147,483,647. So the first change is to declare fibo<\/code> and nacci<\/code> as unsigned int<\/em> values and modify printf()<\/em> to use the %u<\/code> (unsigned int<\/em>) placeholder. The maximum value stored in an unsigned int<\/em> is 4,294,967,295. Is that big enough?<\/p>\n
Here is the last part of the program’s output:<\/p>\n
1640003618\r\n3381276215\r\n726312537\r\n4107588752\r\n538933993\r\n351555449\r\n890489442<\/code><\/pre>\n
No, overflow is still occurring.<\/p>\n
The next step is to change the int<\/em> type to long<\/em>, but I’ll leapfrog that option and go straight to the unsigned long long<\/em> variable type, which stores a range of values from zero to 18,446,744,073,709,551,615.<\/p>\n
The %llu<\/code> placeholder is used in the printf()<\/em> function to display unsigned long long<\/em> integer values.<\/p>\n
After modifying the code, I ran it again. Here is the output’s tail:<\/p>\n
3889924131843504162\r\n223230997310352951\r\n4113155129153857113\r\n4336386126464210064\r\n8449541255618067177\r\n12785927382082277241\r\n2788724563990792802<\/code><\/pre>\n
Again, I don’t see a good sequence, which means that the long long int<\/em> variable isn’t wide enough to hold the 10,000th value in a Fibonacci sequence.<\/p>\n
At this, point I surrender to floating point variables, which removes accuracy but might yield correct values. Variables fibo<\/code> and nacci<\/code> are declared as double<\/em>, and the printf()<\/em> placeholder %E<\/code> is used for exponential notation. Here’s the last part of the output:<\/p>\n
INF\r\nINF\r\nINF\r\nINF\r\nINF\r\nINF\r\nINF<\/code><\/pre>\n
Oh, well. Apparently the 10,000th value in the Fibonacci sequence is INF<\/code> or infinity<\/em>. It’s a number so huge that standard programming variables can’t hold it.<\/p>\n
I scrolled back to see the last legitimate value and it was 1.306989E+308, which is huge and not very accurate.<\/p>\n
The point of this lesson isn’t to discover the 10,000th Fibonacci sequence value, but rather to demonstrate when it’s necessary to switch from int<\/em> to float<\/em> variables and the consequences of doing so.<\/p>\n","protected":false},"excerpt":{"rendered":"
At some point, integer values become so large that you must use floating point variables to hold them. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-2461","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2461","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=2461"}],"version-history":[{"count":7,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2461\/revisions"}],"predecessor-version":[{"id":2475,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2461\/revisions\/2475"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=2461"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=2461"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=2461"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}