Konstanten neu definieren



  • Hallo allerseits

    Ich hab eine für mich aussergewöhnliche Frage.

    Ist es möglich eine Konstante zu definieren? Ich hoffe es erklärt mein Vorhaben.

    Danke für die Hilfe

    wachs

    //array.cpp
    int _ARRAY_SIZE;
    
    //Lässt sich eine Konstante mit einer 
    //präprocessor directive definieren?
    #if ARRAY_SIZE  _ARRAY_SIZE * 2
    #undef ARRAY_SIZE
    #define ARRAY_SIZE _ARRAY_SIZE * 2
    #endif
    
    int *entry_func(const int *Arr,int &arr_size)
    {
    	_ARRAY_SIZE = arr_size;
    	static int array_new[ARRAY_SIZE];
    
    	arr_size *= 2;
    	//Mach was ....
    
    	return array_new;
    }
    
    //main.cpp
    int main()
    {
    	int arr_size = 4;
    	int arr[] = {1, 2, 3, 4};
    	int *arr_new = entry_func(arr, arr_size);
    
    	//usw.
    
    	return 0;
    }
    


  • ja, es ist möglich, eine konstante zu definieren, also einen wert, der schon zur compile-zeit feststeht und sich nicht mehr ändern wird.

    int main ()
      constexpr int SIZE = 42;
      std::array<int, SIZE> array;
    }
    

    wenn du den präprozessor dafür verwendest, dann beachte, dass dieser ein "einfacher" textersetzer ist. du verlierst schon während dem kompilieren jegliche information darüber, was "hinter" der konstante steckt. du kannst z.b. die präprozessor-"konstante" nicht so verwenden, wie normale constexpr ints.

    #define KONSTANTE 42
    
    constexpr int Konstante = 42;
    
    void foo () {
       const int* zeiger = &KONSTANTE; //falsch, "42" ist kein objekt.
       const int* richtig = &Konstante;
    }
    

    der unterschied zwischen constexpr und const ist, dass du mit constexpr ganz explizit sagst, dass du dein objekt als compile-time-konstante verwenden willst. bei const ist das nicht immer/automatisch der fall. mit "const" versprichst nur _du_ als programmierer, dass du den wert einer variablen nicht ändern wirst.

    stiltipp:
    verwende constexpr für diese art von konstante, verwende std::array anstelle von plain-old-arrays für arrays von konstanter größe.

    #include <iostream>
    #include <array>
    using namespace std;
    
    template <int, size_t Size>
    std::array<int, Size> entry_func(std::array<int, Size> array) //kopiere das übergebene array
    {
        for(auto& i: array) i *= 2; //multipliziere jedes element mit 2
        return array; //gib das neue array zurück
    }
    
    //main.cpp
    int main()
    {
        constexpr int arr_size = 4;
        std::array<int, arr_size> arr = {1, 2, 3, 4};
        std::array<int, arr_size> arr_new = entry_func(arr);
    }
    

    dieser code ist *nicht* äquivalent zu deinem code, aber ich vermute, dass du das eigentlich so wolltest. hast du einen bestimmten grund, das von entry_func produzierte array als static zu deklarieren?



  • Guten Tag dove

    Danke für die ausführliche Erklärung.

    Ich habs jetzt total umgeschrieben, und anders gelöst. Ist aber für mich trotzdem sehr interessant sowas zu wissen.

    Einen bestimmten Grund gibt es nicht. Ich hab mich nur gefragt, ob so was überhaupt möglich ist.

    Die Funktion entry_func(); nutze ich nicht nur um eine neue Array zu erzeugen in dem Sinne, sondern ich fülle sie komplett mit Zahlen aus Berechnungen.

    Ich weiss, ein std::array<T, arr_size> oder ein new oder sogar ein std::vector wären da weniger kompliziert und genau so gut gelöst.

    Gut zu wissen. Danke. 👍

    wachs


Log in to reply