Besoin d'octets !!

Bonjour à tous,
Voici mon problème : je suis plutôt nouveau né dans l'univers de la programmation et j'essaye de faire un petit peu tout ce qu'il me passe par la tête pour m'entraîner. J'ai donc décidé de faire un programme en C où l'utilisateur entre un nombre qui est le degré de la suite de Fibonacci qui l'intéresse (par exemple, degré 5 et l'ordinateur affiche 8). Même si vous ne savez pas ce qu'est une suite de Fibonacci, là n'est pas l'important car mon problème est tout autre.
En effet, avec des degrés faibles, le programme fontctionne correctement mais  lorsque j'utilise des hauts degrés, le nombre affiché est plus grand que ma variable de type long. Alors voici ma  question : comment faire pour obtenir des nombres  très grands ? Faut-il créer une variable d'un autre type ? Faut-il créer une varible manuellement et lui allouer de la mémoire de la même façon ? Si oui comment faire ...

Merci d'avance pour toutes vos réponses et bonne continuation à tous.

Niwrad

il y a le type long long sur 64 bits.
Sinon au-delà, faudra créer un autre type, par exemple :
struct int128 {long d[4]};

et coder les fonctions d'opérations, par exemple :

void _Add128(int128*out,const int128*a,const int128*b)
{
   out->d[0]=a->d[0]+b->d[0];
   ...
   return;
}

Une bibli de calculs, par définition ça demande des perfs sinon...

On va faire du unsigned pour l'exemple (mieux pour fibonacci):

typedef struct _BNUINT128 {
  DWORD d[4];
} BNUINT128, *LPBNUINT128;

Déclaration de l'addition (fera a += b):
void __fastcall bnADDu128(LPBNUINT128 a, LPBNUINT128 b);
Si on veut conserver l'original a, en faire une copie préalable.
Toutes opérations en __fastcall, les PUSH et POP ne sont pas gratuits, voire très couteux.

Fichier ASM 32 bits:
bnADDu128 PROC ; ecx = *a, edx = *b
  mov   eax, [edx]
  add   [ecx], eax
  mov   eax, [edx+4]
  adc   [ecx+4], eax
  mov   eax, [edx+8]
  adc   [ecx+8], eax
  mov   eax, [edx+12]
  adc   [ecx+12], eax
  ret   0 ' RIEN A DEPILER
bnADDu128 ENDP

Fichier ASM 64 bits:
bnADDu128 PROC ; rcx = *a, rdx = *b
  mov   rax, [rdx]
  add   [rcx], rax
  mov   rax, [rdx+8]
  adc   [rcx+8], rax
  ret   0 ' RIEN A DEPILER
bnADDu128 ENDP

La soustraction est triviale sur le même modèle, mutiplication et dividion sont un peu plus intéressantes.

ciao...
BruNews, MVP VC++