El número más grande en C

scanf("%d",&a);
for(b=1;b<=a;++b)
{
    c*=b;
}
printf("%lu",c);

¡Quiero obtener la respuesta de 100!
factorial de 100. ¿cómo puedo obtener esto? (Quiero obtener un mayor rango de números) ¿No podemos tener el límite de números hasta el infinito?

El rango máximo de enteros es, en casi todas las plataformas (modernas), 2^31 - 1 (aunque, por norma, int solo se requiere que tenga al menos 16 bits). Para su plataforma determinada, se definirá como INT_MAX en <limits.h>.

100! obviamente superará con creces esto. Para calcular algo tan grande en Cnecesitará una gran biblioteca de enteros, como BPF.

Solo como nota de advertencia, si decide probar y usar un double (que puede contener números de este tamaño), obtendrá una respuesta incorrecta debido a la pérdida de precisión. Esto es fácil de detectar: ​​en mi máquina, los últimos dígitos son 48que obviamente es una tontería: 100! debe ser divisible por 100, por lo tanto debe tener 00 como los dos últimos dígitos.

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#if __STDC_VERSION__>=199901L
#include <inttypes.h>
#else
#define PRIu16 "hu"
#endif

typedef struct _unums {
    size_t size;
    uint16_t *nums;//array 
} UNums;

void UNums_init(UNums *num, uint16_t n){
    num->nums = (uint16_t*)malloc(sizeof(uint16_t));
    num->nums[0] = n;
    num->size = 1;
}

void UNums_mul(UNums *num, uint16_t n){
    uint16_t carry = 0;
    size_t i;

    for(i=0;i<num->size;++i){
        uint32_t wk = n;
        wk = wk * num->nums[i] + carry;
        num->nums[i] = wk % 10000;
        carry = wk / 10000;
    }
    if(carry){
        num->size += 1;
        num->nums = (uint16_t*)realloc(num->nums, num->size * sizeof(uint16_t));
        num->nums[i] = carry;
    }
}

void UNums_print(UNums *num){
    size_t i = num->size;
    int w = 0;
    do{
        --i;
        printf("%0*" PRIu16, w, num->nums[i]);
        if(!w) w = 4;
    }while(i!=0);
}

void UNum_drop(UNums *num){
    free(num->nums);
    num->nums = NULL;
}

int main( void ){
    UNums n;
    uint16_t i;

    UNums_init(&n, 1);
    for(i=2;i<=100;++i)
        UNums_mul(&n, i);
    UNums_print(&n);//100!
    UNum_drop(&n);
    return 0;
}

Para números pequeños es mejor usar unsigned long long que int. Pero aún tiene un límite en el número más grande que puede usar para a. Tu podrías intentar double o float pero es posible que obtenga un error de precesión.

Puedes usar biblioteca GMP

Instalar con:

sudo apt-get install libgmp3-dev

C Principal:

#include <gmp.h>

void f() tooBigForYourShell {
    mpz_t n;                     // declare a big n number
    mpz_init_set_ui(n,0);        // assign 0 as starting value
    mpz_setbit(n, 1UL << 24);    // set bit 2^24 (index 2^24 and not 24...) as 1.
    gmp_printf("%Zd\n", n);      // display the result
}

int main() {
    tooBigForYourShell();
    return 0;
}

Compilar con:

gcc main.c -lgmp && ./a.out

???

profit, enjoy your 2^(2^24) number on stdout.

NB: Hay muchos más dígitos antes…

Tú podrías teóricamente suba a 37 bits usados ​​(entonces 2^38 – 1 ?) pero tenga cuidado ya que usará una gran cantidad de su CPU.

/!\ NO SOY RESPONSABLE DE NINGÚN DAÑO SI USTED OPTA POR 2^(2^37).