die Frage kam schon öfters, aber trotzdem.

Ich muss ein Array mit einer Längenvariablen nutzen, die erst zur Laufzeit bekannt ist.

Sprich so etwa:
int a[var];
Das Problem ist, dass ich keinen Pointer nehmen kann und, dass ich auch keine Liste nehmen kann um toArray() auszunutzen. Es muss aber ein 'echtes' c-Array sein. Ich nutze eine Bibliothek, die unbedingt ein Array und keinen Pointer haben will (auch keine selbstgebastelete Klasse, die ein Array imitiert).
Fragt mich nicht, warum das mit einem Pointer nicht geht, habe mich auch gewundert, aber naja...

Gibt es denn die Möglichkeit, ein Array mit einer Größe zu erstellen, die zur Kompelierzeit nicht bekannt ist???

Ich nutze VisualStudio C++ 6.0...

Danke schonmal

Gibt es denn die Möglichkeit, ein Array mit einer Größe zu erstellen, die zur Kompelierzeit nicht bekannt ist???

Nein gibt es nicht. Nicht so wie du es willst.

Bei templates geht es nicht(spezialisierung zur compile-zeit), beim array kannst du einfach einen pointer übergeben(natürlich nur mit dem größenparameter), oder falls es soetwas nicht gibt, kannst du auch erst einmal eine feste übergabe einprogrammieren, dann in die assembler sicht wechseln, und den code kopieren und umgewandelt als inline assembler einzufügen(zumindest bei x86).

Fragt mich nicht, warum das mit einem Pointer nicht geht, habe mich auch gewundert, aber naja...

frag' ich dich aber. normalerweise kann man fast überall wo ein array erwartet wird auch pointer nehmen.
ansonsten: nimm C99, da gibt es variable-length arrays. die werden tatsächlich so angelegt, wie du es haben willst...

Fragt mich nicht, warum das mit einem Pointer nicht geht, habe mich auch gewundert, aber naja...

Dann frage ich, wie eine typische Funktionsdeklaration mit so einem Parameter aussieht.

Nun, aufrufen kann ich die Funktion, aber es kommt etwas falsches bei raus...

sie sieht so aus

Die Funktionsdeklaration im Header...
size_t funk(void const *src, size_t srcSize, char *dest, size_t destLen);

Mein Code (Ausschnitt...)
1) int src[5];
2) int *src=(int*)malloc(5*sizeof(int));

size_t size = funk(&(src[0]), sizeof(src), param1, param2);

mit 1) funktioniert es, mit 2) nicht.
2) funktioniert noch nicht einmal, wenn ich einen festen Wert, wie oben die 5, eingebe.
Die 5 in 2) soll dann natürlich dann die Variable sein, die zur Kompelierzeit noch nicht definiert ist...

void f(int* p, unsigned length)
{
    int* p2 = static_cast<int*>(alloca(sizeof(int) * length));
    // p2 verwenden
    // ...

} // <- hier "verschwindet" der von alloca angeforderte Speicher automatisch

Natürlich solltest du alloca nicht mit "Klassentypen" verwenden, zumindest mit nichts was einen Destruktor hat, denn dieser wird nicht aufgerufen.
Das tolle an alloca ist nicht nur dass der Speicher bei verlassen der Funktion automatisch freigegeben wird, sondern auch dass alloca verdammt schnell ist.

Intern passiert im übrigen genau dasselbe wie in C99 mit variable-length-arrays, d.h. der Speicher wird vom Stack genommen. Das bedeutet allerdings auch dass man nicht zuviel anfordern sollte, der Stack ist ja üblicherweise nicht sehr gross.

template<typename T>
bool allocate(T** data, const std::size_t size)
{
    *data = new T[size];
    return (*data);
}

BTW: dann nehm' ich aber gleich std::vector bevor ich new verwende...

int  source1[5];
int* source2 = new int[5];
sizeof(source1) // == 5*4 = 20 Byte;
sizeof(source2) // == 1*4 =  4 Byte;
// Jedenfalls auf meinem System

Deshalb sollte man bei dynamisch angelegten Arrays die Größe mitspeichern.

Gruß
Don06

@Dennis123: Ich werde das morgen gleich mal testen. Hört sich aber logisch an. Werde morgen berichten, ob es funktioniert hat oder nicht.

Auch an alle anderen ein herzliches Dankeschön.

Viel Grüße Manfred

Vielen Dank an alle, die hier geantwortet haben.

Gruß Manfred