Typkonvertierung

[Michael (Gast)]

Hallo,

ich habe ein Problem mit einer Konvertierung.
mein funktionierendes Beispiel sieht so aus:

typedef std::complex<double> Complex;
typedef std::valarray<Complex> CArray;

const Complex test[] = { 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 };
CArray data(test, 8);

ich möchte nun gern Daten aus einem Array vom Typ int konvertieren, 
damit ich dynamische Daten hier verarbeiten kann.

Leider ist das Ergebnis immer 0:

int do_fft(int* daten,int points)
{
    Complex *f_arr;

    f_arr=(Complex*)malloc((points+1)*sizeof(Complex));
    if(f_arr==NULL)
      {
        cerr << "Kein Ram vorhanden"<<endl;
        exit(1);
      }
    int i=0;

    //Float Werte erzeugen

    for(i=0;i<points;i++)
    {
      *f_arr=*daten*1.0;
      f_arr++;
      daten++;
    }



    const Complex test[] = { 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 };
    //CArray data(test, 8);
    //CArray data(*f_arr, points);
     CArray data((Complex*)daten, points);
}

Ich habe es mit allesn drei Varianten (Die letzten drei Zeilen im Code) 
getestet, es funktioniert nur mit den Konstanten.
Wäre nett wenn jemand hier helfen könnte.

Dank und Gruß Michael

[Rufus Τ. F. (rufus)]

Michael schrieb:
> f_arr=(Complex*)malloc((points+1)*sizeof(Complex));

Du verwendest C++. Was soll da malloc?

f_arr = new Complex[points + 1];

Michael schrieb:
> const Complex test[] = { 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 };

Wieviele Elemente hat das Array? Nein, das dürften nicht 8 sein.

[Dirk B. (dirkb2)]

Michael schrieb:
> //CArray data(*f_arr, points);

Kann da der Dereferenzierungsoperator zuviel sein.
Allerdings ist zu diesem Zeitpunkt der Bereich auf den f_arr dann zeigt 
ungültig.

Du solltest niemals den Zeiger, der eine Rückgabe von malloc speichert, 
verändern. Bzw erst dann, wenn das free() dazu gemacht wurde.

[Michael (Gast)]

Vielen Dank,

jetzt habe ich dank der Unterstützung einen Weg gefunden.


Gruß Michael

[Vincent H. (vinci)]

Ich versteh das Problem nicht? std::complex besitzt folgenden 
Konstruktur:

complex( const T& re = T(), const T& im = T() );

Das heißt

auto c = complex(42.0);

compiliert ohne dass man einen Imaginärteil angeben muss.

Und nachdem sich int impliziet nach double konvertieren lässt geht auch 
folgendes

auto c = complex(42);

Und damit lässt sich in Folge etwa copy_n nutzen und man landet bei 
einem Einzeler -> https://godbolt.org/z/4C_oky