2 Dimensionalen Array an konstruktor übergeben



  • Hallo leute. Sorry wenn es so ein Thema schon gab ich habs gesucht nichts passendes gefunden, bin ein newbie in c++
    Habe folgendes problem. Der konstruktor soll ein komplettes 2 Dim. Array entgegennehmen und halt in der Class unter private: ´übergeben..
    Hier ist die Klasse und der Konstruktor und das Array in main(); also ich weis das der Konstruktor falsch ist 😢 finde aber kein pasendes ergebnis.. könte jemand helfen brauche es sehr dringen.

    THX voraus...

    class wdr
    {
    public:
    
            wdr(float temper); //Konstruktor
    
            ~wdr(); // Destruktor
            void auswertung();
            void ausgabe();
    
    private:
           float temperatur[4][10];
           float maxi_tmp, mini_tmp,schnitt;
           int max_zeit_std, min_zeit_std, max_zeit_min, min_zeit_min;
    };
    
    wdr::wdr(float temper[4][10])
    {
    float temperatur = temper[4][10];
    }
    
    void main(void)
    {
    
    float temp[4][10] = {
                         {5,5,8,5,12,42,10,52,1,5},
                         {6,5,4,5,6,5,4,5,6,45},
                         {4.4,5.8,7.4,4,1,4,1,4,19,8.45},
                         {45,21,26,2.5,22,34,41,1.0,18,9.9}
                        };
    
    }
    


  • momment, war nicht richtig nachgedacht.. ich denke nochmal 😉



  • ok bin mal gespant 🙂 muss das irgendwie mit zeigern sein ? 🙄



  • kommt drauf an, was du willst.. so wärs eine kopie.

    (ohne gewähr ...)

    class wdr
    {
    private:
           float temperatur[4][10];
    public:
    	wdr(float temper[4][10]) {
    
    		for (int i=0; i<4; i++){
    			for (int j=0; j<10; j++){
    				temperatur[i][j]=temper[i][j];
    			}
    		}
    
    		//test
    		for (i=0; i<4; i++){
    			for (int j=0; j<10; j++){
    				cout<<temperatur[i][j];
    			}
    			cout<<endl;
    		}
    	} 
    
    	~wdr(){}      
    };
    
    int main() //bitte an den standard int main halten.
    {
    
    	float temp[4][10] = {
    						 {5,5,8,5,12,42,10,52,1,5},
    						 {6,5,4,5,6,5,4,5,6,45},
    						 {4.4,5.8,7.4,4,1,4,1,4,19,8.45},
    						 {45,21,26,2.5,22,34,41,1.0,18,9.9}
    						};
    	wdr w(temp);
    
    }
    


  • hy,

    du musst dem konstruktor sagen welche paramenter er übernimmt. In dem fall also ein 2D-arrey:

    wdr(float temper[4][10]);
    

    Mit Dem Ausdruck:

    float temperatur = temper[4][10];
    

    erreichst du nur das das arreyelement [10][4] der variable temperatur zugewiesn wird, die du im konstruktor erzeugt hast (nicht die instanzvariable temperatur)



  • und so würdest du auf dem original abeiten.. also nur eine zeigerübergabe machen
    (ebenso ohne gewähr.. )

    class wdr
    {
    private:
           float  (*temperatur) [10];
    public:
    	wdr(float temper[][10]) {
    
    		temperatur = temper;
    
    		//test
    		for (int i=0; i<4; i++){
    			for (int j=0; j<10; j++){
    				cout<<temperatur[i][j];
    			}
    			cout<<endl;
    		}
    	} 
    
    	~wdr(){}      
    };
    
    int main() 
    {
    
    	float temp[4][10] = {
    						 {5,5,8,5,12,42,10,52,1,5},
    						 {6,5,4,5,6,5,4,5,6,45},
    						 {4.4,5.8,7.4,4,1,4,1,4,19,8.45},
    						 {45,21,26,2.5,22,34,41,1.0,18,9.9}
    						};
    	wdr w(temp);
    
    }
    


  • BOHHHH 😮 ihr seit echt gut :))) Hab beide möglichkeiten ausprobiert 🙂 und beide klappen VIELEN DANK AN EUCH.. für die schnelle hilfe. Und genau das mit dem Zeiger hab ich gesucht, das mit dem kopieren hab ich mir schon auch überlegt aber ich brauchte ne andere lösung... danke nochmal 👍 👍



  • Hi!

    Wenn du

    wdr(float temper[][10]);
    

    verwendest, solltest du die 1. Dimension als 2. Parameter übergeben. Dieser kann dann variabel sein, der 2 muss allerdings weiterhin 10 sein:

    wdr(float temper[][10], std::size_t dim1);
    

    Das ist dann für die Schleife flexibler, dann kannst du statt auf i<4 auf i<dim1 prüfen. Wenn du 2 unbekannte Dimensionen übergeben willst musst du es so machen:

    wdr(float* temper, std::size_t dim1, std::size_t dim2);
    

    Dann kannst du in der äußeren Schleife auf i<dim1 und in der inneren mit j<dim2 prüfen lassen. Zugriff auf das Array erfolgt dann so:

    temper[i*dim2+j]
    

    Letzteres ist die flexibelste Möglichkeit ein 2 dimensonales Array zu übergeben, falls man mal die Größe ändern muss, braucht man es nur noch beim Array selbst zu tun, da man die Dimensionsgrößen mit sizeof-Audrücken berechnen kann:

    // 1. Dim:
    std::size_t szDim1 = (sizeof(arr)/sizeof(arr[0]));
    
    // 2. Dim:
    std::size_t szDim2 = (sizeof(arr)/sizeof(arr[0][0])) / (sizeof(arr)/sizeof(arr[0]));
    

    In deinem Fall wäre arr dann temper.

    Code-Hacker



  • hehe..

    und ganz nebenbei ist das auch die antwort auf meine frage von letztens.
    ich hatte sie nur ungeschickt formuliert.. danke euch 🙂

    gruss

    eviluser


Log in to reply