få et loop til at tælle meget højt

For det først sætter du variablen til at være en long int så kan du så lave løkker i løkker

for (i=0;i<1000000000;i++)
  for (j=0;i<700;i++)
   
Er ikke sikker, men måske du kan bruge en float som variable type og så lade den gøre fra 0-700000000000, men ellers er metoden løkke i løkke.

#include <stdio.h>

void main(void)
{
    float i;
    for(i=0;i<700000000000;i++);
    printf("%12.0f",i);
}

Jeg tror ikke at det vil være smart at bruge floating point til
en løkke. Man kunne meget nemt risikere en uendelig løkke (for store
floating point kunne x+1 godt være x).

int og long int er det samme på de fleste moderne compilere.

En mulighed er den dobbelt løkke.

Men den mest generelle løsning må være en 64 bit integer.

De fleste moderne compilere understøtter en sådan. Typisk
hedder den long long int.

Eksempel:

#include <iostream>
#include <cmath>

using namespace std;

int main()
{
  for(long long int i = 0; i < (long long int)pow(70.0,10.0); i++) {
      cout << (double)i << endl;
  }
  return 0;
}

Hvis din compiler ikke kender long long int, så hedder den sikkert __int64 !

Og så er der inttypes.h fra C99:

#include <iostream>
#include <cmath>
#include <inttypes.h>
int main() {
  for (uint64_t i = 0; i < (uint64_t)std::pow(70.0,10.0); ++i) {
    std::cout << i << std::endl;
  }
  return 0;
}

>>olennert

  Din løsning virker lige efter hensigten..Gider du ikke lægge et svar med en kort forklaring på hvad unit64_t betyder?

inttypes.h indeholder de følgende typer:
int8_t er en 8-bit heltalstype med fortegn
int16_t er en 16-bit heltalstype med fortegn
int32_t er en 32-bit heltalstype med fortegn
int64_t er en 64-bit heltalstype med fortegn
Og så findes de tilsvarende heltalstyper uden fortegn uint8_t, uint16_t, uint32_t og uint64_t, samt
intptr_t er en heltalstype med fortegn, stor nok til at indeholde en pointer.
uintptr_t er en heltalstype uden fortegn, stor nok til at indeholde en pointer.

Så uint64_t er altså en heltalstype for 64-bit heltal uden fortegn. Du kan altså smide tal mellem 0 og 2^64 - 1 (18446744073709551615) ind i en uint64_t. Heldigvis er 70^10 = 2824752490000000000, så der er altså plads til det tal i en uint64_t (og i en int64_t for den sags skyld).