Entero de 10 elevado a 1000

[lluk]

Hola, estoy haciendo un problema que necesito un entero tal que:

n< 10 a la 6
y otro tal que
n< 10 a la 1000

me podéis decir que tipo tendría que usar?
con el long long no me entra

gracias de antemano

EDITO: encontré otra forma de hacer el programa, pueden cerrar el post

[lluk]

para no abrir tema nuevo,
saben como puedo hacer para escribir por ejemplo:
100000000
y que cada numero se guarde en un a posicion de un arreglo distinta?

[Akai]

Creo que primero necesitas aprender sobre numeración en el ordenador.

Con enteros NO te va a entrar, usa floats (doubles si eso)

Con un long, suponiendo que el int es de 32, el long es de 64, lo que da 2^63 (a la 64 si es unsigned), que es mucho menor que 10^63, ya ni te digo 10^1000

Para tu segunda duda, hay mil formas, una de ellas utilizar sprintf para imprimir el número a una cadena de carácteres,

[pucheto]

O puede usar strings para representar los enteros ( e implementar todas las op basicas )... double pierde precision a lo tonto en numeros grandes... y en una de esas busca precision numerica...

[ghastlyX]

Más que strings, para programar BigInts la práctica más extendida es usar vectores de enteros, de forma que en cada posición no se guarda un único dígito, sino varios de ellos, permitiendo aprovechar las operaciones de las variables nativas del lenguaje y además haciendo el cálculo de forma mucho más eficiente.

He picado un ejemplo para poder hacer potencias. No lo he testeado así que quizá tenga algún bug, pero la idea en sí creo que se entiende con el código.

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <vector>
#include <sstream>
#include <iomanip>
using namespace std;

typedef long long ll;
typedef vector<ll> VL;

const ll base = 1000000000;

class BigInt {
    public:
        VL v;
        int signo;

        BigInt() {
            v = VL(1, 0);
            signo = 1;
        }
        BigInt(ll x) {
            do {
                v.push_back(x%base);
                x /= base;
            } while (x > 0);
            signo = 1;
        }
        void operator*=(const BigInt& b) {
            BigInt c;
            c.v.resize(v.size() + b.v.size(), 0);
            c.signo = signo*b.signo;
            for (int i = 0; i < v.size(); ++i) {
                for (int j = 0; j < b.v.size(); ++j) {
                    int k = i + j;
                    c.v[k] += v[i]*b.v[j];
                    while (c.v[k] >= base) {
                        c.v[k + 1] += c.v[k]/base;
                        c.v[k++] %= base;
                    }
                }
            }
            int i;
            for (i = c.v.size() - 1; i > 0 and c.v[i] == 0; --i);
            c.v.resize(i + 1);
            *this = c;
        }
        BigInt pow(ll k) {
            if (k == 0) return BigInt(1);
            BigInt res = this->pow(k >> 1);
            res *= res;
            if (k&1) res *= (*this);
            return res;
        }
        friend ostream &operator<<(ostream &out, BigInt &b) {
            if (b.signo < 0) out << '-';
            int i = b.v.size() - 1;
            out << b.v[i];
            for (--i; i >= 0; --i) out << setw(9) << setfill('0') << b.v[i];
            return out;
        }
};

int main() {
    BigInt x(10);
    x = x.pow(1000);
    cout << x << endl;
}