We can classify computation in several categories.
For one: A significant context for computing is some form of indexing. We can index into an array, for example. Another form is that we can count objects (e.g. give them an int id) that we create in memory.
For these, our programming languages are usually implemented so that they run out of memory before the simple integer type overflows. For example, arrays may be limited to 32k in 16-bit worlds (and you could only have one of those), 2^31 elements in 32-bit worlds. And you cannot create more than 32k objects in 16-bit worlds and 2^31 object in 32-bit worlds (because objects almost universally use more than one byte each). We can consider that in some sense, larger and large int values imply more memory usage, and that memory is exhausted just before simple int's overflow.
For another, however, we have kinds of computation that doesn't use additional memory in proportion with larger numeric values, such as, summation, we need to be very careful about the selection of data type. Other examples would be rows in a database, where the row number (row id) could exceed memory size as much of the data lives on disc instead of in memory. In these cases we have to look to other limits to indicate the proper size to use. For example, if the db limits to 2^63 rows (big db!), then we should be ok to use a 64-bit int regardless of if we're using a 16-bit machine or larger.