Problem mit Funktionen und Arrays



  • habe ein Problem mit der Nutzung von Arrays. Ich habe ein double Array Spectrum[], welches ich aus einer anderen Funktion erhalten, und muss dieses nun weiter verarbeiten. Dazu habe ich folgende Funktion programmiert:
    (Auszug)

    double CDA_AVG(double Spectrum[],double Wavelength[] ,const unsigned NoSen,const unsigned DeltaPix){
    
    //	 detect Sensor Position
    	unsigned pos[NoSen];
    	double dmax[NoSen];
    	//double Spectrumhelp[]=Spectrum;
    	for (unsigned k=0;k<NoSen;k++){
    		//find max		
    		pos[k]= 0;		
    		dmax[k]= Spectrum[0];
    		for (unsigned i = 0; i < sizeof(Spectrum)/sizeof(double); i++)
    		{
    			if (Spectrum[i] > dmax[k])
    				{
    					dmax[k] = Spectrum[i];
    					pos[k] = i;
    			} 	
    		}
    
    		//dmax[k] ist der Max-wert
    		//pos[k] ist die Position des Max-wertes
    .....
    

    Das Problem ist nun, dass er für den Array-Aufbau immer eine konstante Zahl haben will, obwohl ich "NoSen" und "DeltaPix" als konstant angegeben habe. Was kann ich machen? Kann ich Arrays evtl in Vekoren konvertieren und diese dann einfach verarbeiten?



  • ja ist doch klar

    die werte die 'NoSen' und 'DeltaPix' annehmen können sind warhscheinlich erst zur laufzeit bekannt
    also brauchst du dynamische arrays

    double CDA_AVG(double Spectrum[],double Wavelength[] ,const unsigned NoSen,const unsigned DeltaPix){
    
    //     detect Sensor Position
        unsigned *pos = new unsigned[NoSen];        // per zeiger dynamsich gemacht
        double *dmax = new double[NoSen];
        //double Spectrumhelp[]=Spectrum;
        for (unsigned k=0;k<NoSen;k++){
            //find max       
            pos[k]= 0;       
            dmax[k]= Spectrum[0];
            for (unsigned i = 0; i < sizeof(Spectrum)/sizeof(double); i++)
            {
                if (Spectrum[i] > dmax[k])
                    {
                        dmax[k] = Spectrum[i];
                        pos[k] = i;
                }    
            }
    
            //dmax[k] ist der Max-wert
            //pos[k] ist die Position des Max-wertes
    .....
        // aber nun delete nicht vergessen
        // und du kannst die neu erstellten arrays, also pos und dmax nicht ausserhalb der funktion nutzen
        delete[] pos; 
        pos = NULL;
        delete[] dmax; 
        dmax = NULL;
    

    EDIT: ups hab noch nichtmal richtig hingeschaut
    folgendes klappt nicht

    for (unsigned i = 0; i < sizeof(Spectrum)/sizeof(double); i++)
    {
       // blabla
    }
    

    da 'Spectrum' intern per zeiger übergeben wird sagt er dir die grösse für genau das erste element sprich für double
    da du double danach nochmal abfragst kommt eins heraus

    deine schleife wird also nur 2 mal durchlaufen...
    egal was passiert

    in solchen fällen musst du dir eine weitere variable mit übergeben lassen die die array grösse angibt...

    void test(double arr[], const int anz)
    {
        for(int i = 0; i < anz; ++i)
        {
        }
    }
    


  • Dein Problem ist, das die variable NoSen trotzdem jeden beliebigen Wert annehmen kann. Du kannst die Funktion verschiedenen Werten aufrufen die sich zwar dann innerhalb der Funktion nicht verändern können, aber trotzdem vom Aufruf abhängen

    int main()
    {
    double CDA_AVG(/*...*/,/*...*/ ,4,5)
    double CDA_AVG(/*...*/,/*...*/ ,8,9)
    }
    

    Du siehst, beides mal verschiedene Größen für die Arrays
    Was du machen kannst ist einen Zeiger zu benutzen:

    #include<iostream>
    using namespace std;
    
    int main()
    {
    int j;
    cin>>j;
    unsigned *pos=new unsigned[j]; 
    }
    

    Die array mußt du dann wieder mit delete zerstören

    edit1: zu spät 😉



  • Danke erstmal.Ich muss vllt noch dazu sagen, dass ich eigentlich sonst nur mit Matlab programmiere(einfach zu lösen, aber langsam) und die Funktion bereits in Matlab implementiert ist. Daher sind vielleicht einige Stellen nicht sehr intelligent programmiert, da ich mich eben an dem Matlab Quelltext entlang gehangelt hab 😃
    Also die in der Funktion dynamisch erzeugten Arrays können nicht ausgegeben werden. Jetzt möchte ich aber gerne als "Ergebnis" der Funktion eigentlich nicht nur ein double Wert ausgeben, sondern ein ganzes Array von double-Werte, die innerhalb eben dieser Funktion berechnet werden. Das wird ja dann schwierig mit den dynamischen Arrays...

    double CDA_AVG(double Spectrum[],const unsigned speclen,double Wavelength[],const unsigned wavlen,const unsigned NoSen,const unsigned DeltaPix)
    ...
    ...
    double *WLCOG=new double[NoSen];
    ...
    ...
    double summe=0;
    		for(unsigned q=0; q<=sizeof(H_WLCOG) / sizeof(double);q++){
    			summe=summe+H_WLCOG[q];}
    		WLCOG[l]=summe/(DeltaPix-1);
    	}
    
    delete[] pos;
        pos = NULL;
        delete[] dmax;
        dmax = NULL;
    	delete[] H_WLCOG;
        H_WLCOG = NULL;
        delete[] WLCOG;
        WLCOG = NULL;
    	return WLCOG[2];   //erstmal nur einen Wert zurückgeben
    


  • std::vector ist besser als sich selber um den Speicher für die arrays zu kümmern.



  • also es gibt die unschöne möglichkeit alle benötigten arrays global zu machen und sie eventuell auch konstant (also double test[15]) festzulegen

    oder du übergibst arrays und lässt sie dir zurückgeben...

    beispiel wie das ganze geht:

    int main()
    {
       int a;
       cin>> a;
       double *arr;
    
       arr = initArray(arr, a);
       ArrayRechnen(arr, a);
       ausgeben(arr, a);
    
       delete[] arr;   
    }
    // ich schreibe die funktionen bewusst drunter ohne prototypen...
    
    double* initArray(double *arr, const int anzahl)
    {
        arr = new double[anzahl];
        return arr;
    }
    
    void ArrayRechnen(double *arr, const int anzahl)
    {
        for(int i = 0; i < anzahl; ++i)
            arr[i] = anzahl+(i*i)-i;     // oder whatever...
    }
    
    void ausgeben(double *arr, const int anzahl)
    {
        for(int i = 0; i < anzahl; ++i)
            cout << arr[i] << endl;
    }
    

    so verfährt man in C++ mit arrays
    wobei man auch immer schreiben könnte

    void name(double arr[], const...)
    


  • mr taylor schrieb:

    std::vector ist besser als sich selber um den Speicher für die arrays zu kümmern.

    also meine Daten, die ich bearbeiten/verrechnen will(Spectrum[]), liegen auf jeden Fall als ein double array vor. Kann man die einfach in eine vector -Typ konvertieren?



  • habe leider noch nicht rausfinden können, ob und wie man ein double array in einen Vektor umwandeln kann...hat jemand von Euch eine Idee?



  • const int groesse = 10;
    
    double dasArray[groesse];
    //das Array füllen...
    
    std::vector<double> derVector;
    derVector.resize(groesse);
    for(int i=0; i < groesse; i++)
    {
        derVector[i] = dasArray[i];
    }
    

    glaube ich zumindest...



  • elsucht schrieb:

    habe leider noch nicht rausfinden können, ob und wie man ein double array in einen Vektor umwandeln kann...hat jemand von Euch eine Idee?

    double a[100];
    	 std::vector<double> b (a, a+100);
    


  • Erstellen:

    int size = 10;
    
    double *pD1 = new double[ size ];
    
    sd::vector<double> myVec( pD1, pD1 + size );
    

    Neue Werte am Ende hinzufügen:

    myVec.push_back( 0.1 );
    

    Ganzes Array am Ende hinzufügen:

    size = 5;
    
    double pD2 = new double[ size ];
    
    myVec.insert( myVec.end(), pD2, pD2 + size );
    

    Vector freigeben:

    myVec.clear();
    


  • double pD2 = new double[ size ];

    Das schauen wir uns aber nochmal an.

    rean schrieb:

    myVec.clear();
    

    Autsch. Wie wäre es, wenn du den Speicher noch freigeben würdes, bevor du den vector leerst?


Log in to reply