Question: Is it possible to define `999e999` value without using the `char` type?

I've tried defining it even with `unsigned long long`, but the compiler keeps giving me `constant too big` error.

Thanks in advance.

Answer: 
> 
> Is it possible to define `999e999` value without using the char type?
> 
> 
> 

No, that's not possible using intrinsic c++ data types. That's a way to big number that could be held in either a `unsigned long long` type in c++.

A `long double` type would enable you to use 10 based exponents as large as you want, for modern FPU architectures.

What can be achieved with your current CPU architecture can be explored using the [`std::numeric_limits`](https://en.cppreference.com/w/cpp/types/numeric_limits) facilities like this:

```
#include <iostream>
#include <limits>

int main() {   
   std::cout<< "max_exponent10: " << std::numeric_limits<long double>::max_exponent10  << std::endl;
}

```

Output:

```
max_exponent10: 4932

```

See the [online demo](http://coliru.stacked-crooked.com/a/652a1733413070aa)

You have to use a 3rd party library (like [GMP](https://gmplib.org/)) or write your own algorithms to deal with big numbers like that.
> 
> I've tried defining it even with unsigned long long, but the compiler keeps giving me constant too big error.
> 
> 
> 

Of course it does. A `long long` is typically 64 bits long, which gives you `log(2^64) ≅ 19` decimal digits of precision. `999e999 ≅ (10^3)^1000`, so is on the order of 3000 decimal digits long, or nearly 10,000 bits long. So `999e999` isn't just too big for a `long long`, it's too big by an enormous margin.

> 
> Is it possible to define 999e999 value without using the char type?
> 
> 
> 

Sure. You could define an integer-like type based on an array of some sort of integers, like `long long`. You'd still need to write a set of operators to work with your new giant type, though. Also, most of the time when you're working with numbers that large, you don't need an exact representation, which is why floating point types like `float` and `double` are useful.