Geht das irgendwie?

Bislang erstelle ich erst ein vector und kopiere denn dann in ein fftw kompatibles c-Array rechne mit fftw und kopiere danach wieder in den vector.
Der Nachteil dabei, mal abgesehen von der zusätzlichen Zeit die zum kopieren verloren geht ist der doppelte Speicherbedarf.

Und wenn du vorsichtig genug bist, kannst du dir mit &v.front() die vector<>-Inhalte als Array verwenden

Das liefert die Adresse des Iterators. &vector[0] funktioniert.

(letzteres auf eigene Gefahr).

Der Standard garantiert, dass der Speicher an einem Stück und IIRC auch sequentiell ist. Das Einzige, was dann noch schiefgehen könnte, wäre eine rückwärts gespeicherte Sequenz

CStoll schrieb:

Und wenn du vorsichtig genug bist, kannst du dir mit &v.front() die vector<>-Inhalte als Array verwenden

Das liefert die Adresse des Iterators. &vector[0] funktioniert.

front() ist kein Iterator, sondern eine Referenz auf das Element.

CStoll schrieb:

Und wenn du vorsichtig genug bist, kannst du dir mit &v.front() die vector<>-Inhalte als Array verwenden

Das liefert die Adresse des Iterators. &vector[0] funktioniert.

Du kennst den Unterschied zwischen "begin()" und "front()"?

(letzteres auf eigene Gefahr).

Der Standard garantiert, dass der Speicher an einem Stück und IIRC auch sequentiell ist. Das Einzige, was dann noch schiefgehen könnte, wäre eine rückwärts gespeicherte Sequenz

Der Standard garantiert nicht, daß die Daten immer an der selben Stelle bleiben - das kann ins Auge gehen, wenn die aufgerufene Funktion den Zeiger speichert, um später damit arbeiten zu können (hat zwar nichts direkt mit dem Problem zu tun, aber nebenan gibt es eine nette Diskussion über strtok()).
Außerdem mußt du bei solchen Konstruktionen auch auf die Größe des vector<>s achten.

Der Standard garantiert nicht, daß die Daten immer an der selben Stelle bleiben -

Wenn die Grösse des Arrays nicht geändert wird, schon. Ansonsten verhält es sich auch nicht anders als bei einem realloc.

Also was genau willst du jetzt erreichen? Du kannst die Inhalte des nackten Arrays per assign() (oder STL-Algorithmen ala copy()) in einen vector<> packen. Und wenn du vorsichtig genug bist, kannst du dir mit &v.front() die vector<>-Inhalte als Array verwenden (letzteres auf eigene Gefahr).

Zunächst muss das Array was ich speichern will richtig ausgerichtet sein. Das wird in einem Code den ich dafür wiederverwende so geprüft:

bool aligned = ( (reinterpret_cast<size_t>(in)&15) | (reinterpret_cast<size_t>(out)&15) ) == 0;

wobei in und out complex<double>* arrays sind.

std:copy kopiert mir doch die Daten? Genau das will ich ja nicht. Das ich auf die Daten des vectors mit &v[0] zugreifen kann weiß ich und würde ich auch nutzen.

Wenn ich mir die Doku zu assign anschauen (http://www.cplusplus.com/reference/stl/vector/assign/) dann sehe ich nicht wie ich damit einen vector den Pointer auf mein c-array übergeben kann.

// Erstellen des Arrays (c-stil, da C-lib)

complex<double>* FFTW::createArray(size_t size)
{
    fftw_complex* array = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * size);
    return reinterpret_cast<complex<double>*>(array);
}

// neu zuordnen zu vector?
int N = 1024;
complex<double>* rawdata = fft.createArray(N);
vector<complex<double> > fftdata;
fftdata.assign(rawdata, rawdata + N;

Hierbei müsste nun rawdata[0] und &fftdata[0] auf exakt denselben Pointer weisen. Ist das so ?

Das was Du möchtest geht mit std::vector einfach nicht. Du kannst Dir aber leicht einen eigenen Container basteln der das Interface für Random Access Container implementiert und dabei nur auf dem Array arbeitet.

Das hatte ich auch schon überlegt. Aber der eigentliche Grund warum ich einen vector und kein pointer array haben möchte ist, das der komplette code außerhalb der fft routine z.B. die mathematischen Routinen aber auch die gui auf std::vector basiert.

Jetzt alles auf einen neuen myvectorfft umzustellen wäre unsinnig weil dann alle mathebibliotheken damit nichts anfangen können oder umgeschrieben werden müssten.

Als ich den ursprünglichen Code übernommen hatte basierte alles auf einer selbstgeschriebenen complex Klasse. Diese Abhängigkeit herauszubekommen war eine sehr umfangreiche Arbeit. Jetzt möchte ich nicht schon wieder so einen Fehler einbauen.

Für die Ausrichtung könnte man einen entsprechenden Allokator adaptieren.

kannst du da genauer werden?

Was genau fftw_malloc macht weiß ich nicht, mal abgesehen von der Ausrichtung im Speicher.

Wenn ich jetzt mit std:vector ein Array erstelle, dann müsste das exact den Anforderungen von fftw entsprechen, da ansonsten die Performance bei der Berechnung einbricht.

"allocate" und "deallocate" müsst du dein "alloc" und dein "free" einsetzen

std:copy kopiert mir doch die Daten? Genau das will ich ja nicht. Das ich auf die Daten des vectors mit &v[0] zugreifen kann weiß ich und würde ich auch nutzen.

Wenn ich mir die Doku zu assign anschauen (http://www.cplusplus.com/reference/stl/vector/assign/) dann sehe ich nicht wie ich damit einen vector den Pointer auf mein c-array übergeben kann.

Iteratoren sind eine Erweiterung von Zeigern für beliebige Container-Klassen - und natürlich kannst du Funktionen wie assign(), die Iteratoren/paare als Parameter erwarten, auch blanke Zeiger übergeben.
Allerdings sollte ich dazusagen, daß assign() die übergebenen Daten ebenfalls in den vom vector<> verwalteten Speicherbereich kopiert.

Das heißt, für deine Zwecke ist der erwähnte Allokator-Ansatz wohl praktischer in der Umsetzung.