Preprocessor Schleife mit definierter Anzahl von Durchläufen


  • Mod

    Die von Boost ist sicher eine gute Wahl. Aber wenn du schon gezielt nach etwas einfachem fragst, dann ist das alles wohl eher nichts für dich. Auf einfache Weise komplexe Aufgaben mit dem Präprozessor zu erledigen geht nämlich nicht.



  • Wie gross ist n? Unter 32 kann man das auch gut selber schreiben.


  • Mod

    unbooost schrieb:

    Wie gross ist n? Unter 32 kann man das auch gut selber schreiben.

    Noch als Nachtrag, wie das an sich selber zu schreiben ist: Dir Grundidee ist folgende:

    #define REPEAT_5(foo) foo REPEAT_4(foo)
    #define REPEAT_4(foo) foo REPEAT_3(foo)
    #define REPEAT_3(foo) foo REPEAT_2(foo)
    #define REPEAT_2(foo) foo REPEAT_1(foo)
    #define REPEAT_1(foo) foo
    
    #define REPEAT(foo, N) REPEAT_##N (foo)
    
    REPEAT(bla!, 3)
    

    Soweit so unübersichtlich. Noch komplizierter wird es, wenn man auch noch berücksichtigen möchte, dass in den Ausdrücken Kommas vorkommen können. Und wahrscheinlich noch ein paar andere Sachen, die ich gerade vergesse. Ich denke es ist klar geworden, wieso man das nicht von Hand schreiben möchte.



  • SeppJ schrieb:

    Ich denke es ist klar geworden, wieso man das nicht von Hand schreiben möchte.

    Ich denke, es ist klar geworden, dass du damit kaum Erfahrung hast.

    #define COMPILE_TIME_LOOP_5() LOOP_ACTION(5) COMPILE_TIME_LOOP_4() 
    #define COMPILE_TIME_LOOP_4() LOOP_ACTION(4) COMPILE_TIME_LOOP_3() 
    #define COMPILE_TIME_LOOP_3() LOOP_ACTION(3) COMPILE_TIME_LOOP_2() 
    #define COMPILE_TIME_LOOP_2() LOOP_ACTION(2) COMPILE_TIME_LOOP_1() 
    #define COMPILE_TIME_LOOP_1() LOOP_ACTION(1)
    
    #define COMPILE_TIME_LOOP(n) COMPILE_TIME_LOOP_ ## n()
    
    int main() {
    #define LOOP_ACTION(i) printf("\n" #i);
      COMPILE_TIME_LOOP(5)
    #undef LOOP_ACTION
    }
    


  • Beziehunsweise so, wenn du wie forwärts durchlaufen willst:

    #define COMPILE_TIME_LOOP_5() COMPILE_TIME_LOOP_4() LOOP_ACTION(4)
    #define COMPILE_TIME_LOOP_4() COMPILE_TIME_LOOP_3() LOOP_ACTION(3)
    #define COMPILE_TIME_LOOP_3() COMPILE_TIME_LOOP_2() LOOP_ACTION(2)
    #define COMPILE_TIME_LOOP_2() COMPILE_TIME_LOOP_1() LOOP_ACTION(1)
    #define COMPILE_TIME_LOOP_1()                       LOOP_ACTION(0)
    

  • Mod

    unbooost schrieb:

    SeppJ schrieb:

    Ich denke es ist klar geworden, wieso man das nicht von Hand schreiben möchte.

    Ich denke, es ist klar geworden, dass du damit kaum Erfahrung hast.

    Ja, denn ich zeige dem absoluten Anfänger nicht gleich die komplizierteste Variante, sondern etwas, das man auch auf Anhieb verstehen könnte. Ich weiß auch nicht, was ich mir dabei bloß gedacht habe. 🙄


  • Mod

    Übrigens ginge das was du machst richtig in dieser Art:

    #define REPEAT_5(foo) foo(5) REPEAT_4(foo)
    #define REPEAT_4(foo) foo(4) REPEAT_3(foo)
    #define REPEAT_3(foo) foo(3) REPEAT_2(foo)
    #define REPEAT_2(foo) foo(2) REPEAT_1(foo)
    #define REPEAT_1(foo) foo(1)
    
    #define REPEAT(foo, N) REPEAT_##N (foo)
    
    #define MY_LOOP_ACTION(N) printf("\n" #N)
    
    REPEAT(MY_LOOP_ACTION, 3)
    

    So muss der Benutzer nämlich nicht deine Implementierungsdetails (LOOP_ACTION) kennen.



  • Und jetzt bitte für größere Anzahlen mit rekursiven #includes.



  • Die #defines in dieser Art und Weise zu verwenden unterliegt natürlich immernoch starken Beschränkungen, wie z.B. dass die maximale Anzahl an Wiederholungen der Anzahl der #defines entspricht. Ist auf jeden Fall ne Alternative, die ich mir merken werde. Allerdings versuche ich mich dann doch erstmal mal mit der Boost, weil ich dann gleich in voller Allgemeinheit arbeiten kann.


  • Mod

    MC schrieb:

    Die #defines in dieser Art und Weise zu verwenden unterliegt natürlich immernoch starken Beschränkungen, wie z.B. dass die maximale Anzahl an Wiederholungen der Anzahl der #defines entspricht. Ist auf jeden Fall ne Alternative, die ich mir merken werde. Allerdings versuche ich mich dann doch erstmal mal mit der Boost, weil ich dann gleich in voller Allgemeinheit arbeiten kann.

    Boost kocht auch nur mit Wasser. Die benutzen natürlich all die Tricks, die ich und andere hier nur am Rande erwähnt haben, ohne sie zu zeigen. Aber im Prinzip steckt da das gleiche hinter, nämlich Ausschreiben aller Möglichkeiten. Insbesondere heißt das, dass es ein Maximum für die Anzahl der Wiederholungen gibt. Näheres ist in der Dokumentation erklärt.

    volkard schrieb:

    Und jetzt bitte für größere Anzahlen mit rekursiven #includes.

    Nein, bitte nicht. Da verweise ich auf den Boost Quellcode. Sofern die das überhaupt benutzen.


Anmelden zum Antworten