Is there a max int length a user can input?

Question

I made a little program to determine the length of a user-provided integer:

#include <iostream>

using namespace std;

int main()
{
    int c=0; //counter for loop
    int q=1; //quotient of number upon division

    cout << "Hello Cerberus! Please enter a number." << endl;
    cin >> q;

    if(q > -10 && q < 10)
    {
        cout << "The number you entered is 1 digit long." << endl;
    }
    else
    {
        while(q != 0)
        {
            q=q/10;
            c++;
        }

        cout << "The number you entered is " << c << " digits long." << endl;
    }
    return 0;
}

It works quite nicely, unless the numbers get too big. Once the input is 13 digits long or so, the program defaults to "The number you entered is 1 digit long" (it shouldn't even present that solution unless the number is between -10 and 10).

Is there a length limit for user-input integers, or is this demonstrative of my computer's memory limits?

Answer 1

It's a limit in your computer's architecture. Every numeric type has a fixed upper limit, because the type describes data with a fixed size. For example, your int is likely to take up either four or eight bytes in memory (depending on CPU; based on your observations, I'd say the former), and there are only so many combinations of bits that can be stored in so many bytes of memory.

You can determine the range of int on your platform using std::numeric_limits, but personally I recommend sticking with the fixed-width type aliases (e.g. int32_t, int64_t) and picking whichever ones have sufficient range for your application.

Alternatively, there do exist so-called "bigint" libraries that are essentially classes wrapping integer arrays and adding clever functionality to make arbitrarily-large values work as if they were of arithmetic types. That's probably overkill for you here though.

Just don't be tempted to start using floating-point types (float, double) for their magic range-enhancing abilities; just like with the integral types, their precision is fundamentally limited, but using floating-point types adds additional problems and concerns on top.

There is no fundamental limit on user input, though. That's because your stream is converting text characters, and your stream can basically have as many text characters in it as you could possibly imagine. At that level, you're really only limited by available memory.