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;
}

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?

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