for-løkke unroll

Øh. Med mindre et-eller-andet er ret komplekst, hvad så med:

void unroll(std::ostream& os)
{
    for (int i = 0; i < 1000; ++i)
    {
        os << "z[" << i << "] = et-eller-andet;" << std::endl;
    }
    os << std::flush;
}

Hvis det ikke skal bruges "hele tiden", så foreligger muligheden for for, at lave et program på max 10 linier, der kan lave din kode som output til en tekst fil...

JP

Så skal du bare åbne en ofstream, og kalde unroll med den som parameter.

Korrekt, det er ikke en generel løsning jeg har her. Men hvis din loop unrolling er enkel, så er dette da en hurtig løsning.

Og det ser ud til at JP er enig med mig :-)

Nu er det jo lidt svært at vide hvad den compiler tillader.

Men hvis følgende trick kan bruges, så vil jeg mene at det var
markant nemmere at vedligeholde:

#include <stdio.h>

#define ONE(base) a[base]=base;

#define TEN(base) ONE(base) \
                  ONE(base+1) \
                  ONE(base+2) \
                  ONE(base+3) \
                  ONE(base+4) \
                  ONE(base+5) \
                  ONE(base+6) \
                  ONE(base+7) \
                  ONE(base+8) \
                  ONE(base+9)

#define HUNDRED(base) TEN(base) \
                      TEN(base+10) \
                      TEN(base+20) \
                      TEN(base+30) \
                      TEN(base+40) \
                      TEN(base+50) \
                      TEN(base+60) \
                      TEN(base+70) \
                      TEN(base+80) \
                      TEN(base+90)

#define THOUSAND(base) HUNDRED(base) \
                      HUNDRED(base+100) \
                      HUNDRED(base+200) \
                      HUNDRED(base+300) \
                      HUNDRED(base+400) \
                      HUNDRED(base+500) \
                      HUNDRED(base+600) \
                      HUNDRED(base+700) \
                      HUNDRED(base+800) \
                      HUNDRED(base+900)

int main()
{
  int i,a[1000];
  THOUSAND(0);
  for(i=0;i<1000;i++) printf("%d\n",a[i]);
}

Det bliver expanderet til 1000 assignments.

Og man kan rette i et-eller-andet expression et sted uden at
skulle genkøre en utility.

Til gengæld skal C compiler preprocessoren kunne accepetere
nogle rimelige lange udtryk.

Hvilket udviklingsmiljø bruger du, understøtter det makroer?
I så fald kunne du lave en lille makro der ændrede koden direkte i dit miljø...

Arnes løsning er bedre end den jeg har skitseret, for du kan holde det hele indenfor den samme kildetekstfil. Men det kræver altså at din oversætters præprocessor kan håndtere store makroer.