2D Array an Funktion übergeben



  • Hi ich hoffe das ist die richtige Kategorie für das Thema.

    Ich hab zwei vorgegebene Funktionköpfe:

    void mul(double* m1[4][4], double* m2[4][4], double* result[4][4])
    
    void add(double* m1[4][4], double* m2[4][4], double* result[4][4])
    

    ich soll also aus meinem Hauptprgoramm drei 2D Felder übergeben aber ich bekomm es einfach net hin. Wie würde ein Bsp. aussehen wenn ich z.B:

    double m1[4][4], m2[4][4], res[4][4];
    

    die drei Felder hab und Sie an die Funktion "mul" übergeben will.



  • double m1[4][4], m2[4][4], res[4][4];
    mul(m1,m2,res);
    


  • Ja das hat ich probiert da kommt das :

    error C2664: 'mul': Konvertierung des Parameters 1 von 'double [4][4]' in 'double *' nicht möglich



  • Dieses ultimativ-große Programm kann mein g++ kompilieren:

    double d1[4][4], d2[4][4], d3[4][4];
    void mul(double d1[4][4], double d2[4][4], double d3[4][4])
    {
    }
    int main ()
    {
    mul(d1,d2,d3);
    return 0;
    }
    


  • das liegt wohl daran das du im funktionskopf die "*"chen vergessen hast

    void mul(double[b]*[/b] m1[4][4], double[b]* [/b]m2[4][4], double[b]* [/b]result[4][4])
    
    void add(double* m1[4][4], double* m2[4][4], double* result[4][4])
    


  • Wasn jetz?

    Wiso willst du pointer benutzen?
    Ich würde die ganze funktion eh komplett anders schreiben...

    ...aber soooo, neimals...



  • kA schrieb:

    Wasn jetz?

    Wiso willst du pointer benutzen?
    Ich würde die ganze funktion eh komplett anders schreiben...

    ...aber soooo, neimals...

    edit: aso, is vorgegeben...



  • richtig 😉 es ist vorgegeben



  • Hehe... so kompilierts meiner...

    ...aber ob du was damit anfangen kannst, kA xD

    double d1[4][4], d2[4][4], d3[4][4];
    void mul(double *d1[4][4], double *d2[4][4], double *d3[4][4])
    {
    }
    int main ()
    {
    mul((double *(*)[4]) d1, (double *(*)[4]) d2, (double *(*)[4]) d3);
    return 0;
    }
    


  • Wenn man reinterpret_cast nicht mag und nicht vorgeschrieben ist, wie die Variablen deklariert werden sollen:

    double *d1[4], *d2[4], *d3[4];
    void mul(double *d1[4][4], double *d2[4][4], double *d3[4][4])
    {
    }
    int main ()
    {
        //2D-Arrays initialisieren
        mul(&d1, &d2, &d3);
    }
    


  • kA schrieb:

    Hehe... so kompilierts meiner...

    ...aber ob du was damit anfangen kannst, kA xD

    double d1[4][4], d2[4][4], d3[4][4];
    void mul(double *d1[4][4], double *d2[4][4], double *d3[4][4])
    {
    }
    int main ()
    {
    mul((double *(*)[4]) d1, (double *(*)[4]) d2, (double *(*)[4]) d3);
    return 0;
    }
    

    Hm da bekomm ich schon mal die Startadresse und er macht ein 2D Array daraus, aber die Werte die dann in dem Array stehen passen nicht.

    @schorsch code naja die funktion mul steht in ner anderen Datei von daher klappt das mit der globalen Deklaration nicht



  • pad8626 schrieb:

    @schorsch code naja die funktion mul steht in ner anderen Datei von daher klappt das mit der globalen Deklaration nicht

    😕 Was hat die "andere Datei" mit einer globalen Deklaration für ein Problem?
    😕 Welche Rolle spielt es für den Aufruf, dass die Variablendeklaration beispielshalber global ist?
    😕 Ist die Deklaration in kAs Beispiel nicht ebenso global?
    😕 Was sagt der Compiler?


  • Mod

    pad8626 schrieb:

    Hi ich hoffe das ist die richtige Kategorie für das Thema.

    Ich hab zwei vorgegebene Funktionköpfe:

    void mul(double* m1[4][4], double* m2[4][4], double* result[4][4])
    
    void add(double* m1[4][4], double* m2[4][4], double* result[4][4])
    

    ich soll also aus meinem Hauptprgoramm drei 2D Felder übergeben aber ich bekomm es einfach net hin. Wie würde ein Bsp. aussehen wenn ich z.B:

    double m1[4][4], m2[4][4], res[4][4];
    

    die drei Felder hab und Sie an die Funktion "mul" übergeben will.

    Das geht nicht. Deine Variablen sind 2-dimensionale Arrays mit dem Elementtyp double. Die Funktionen erwarten dagegen 2-dimensionale Arrays (genauer: Pointer auf eindimensionale Arrays, aber dieser Unterschied spielt hier keine Rolle) mit dem Elementtyp Pointer auf double. Die Aufgabe muss hier scheitern, und kein noch so kreatives und sinnfreies Herumcasten wird daran etwas ändern.



  • ich hab mir mal ein test programm geschrieben

    #include "stdafx.h"
    
    using namespace std;
    
    void test(double* [4][4]);
    
    void main()
    {
    
    	double m1[4][4]={1,2,3,4,5,6,7,8,9,1,2,3,5,1,1,1};
    	double* m1P = &m1[0][0];
    
    	for(int i=0; i<16; i++)
    	{
    		printf("%p %lf\n",m1P,*m1P++);
    	}
    
    	printf("\n\n");
    
    	test((double*(*)[4])m1);
    }
    
    void test(double* m1P[4][4])
    {
    
    	for(int i=0; i<16; i++)
    	{
    		printf("%p %lf\n",m1P,*m1P++);
    	}
    	_getch();
    }
    

    So wie gesagt funtzt so weit nur die werte stimme nicht

    Und hier ist es wie es in der aufgabe sein soll

    Matrix.h

    #ifndef MATRIX_H 
    #define MATRIX_H
    
    void mul(double* [4][4] , double* [4][4], double* [4][4]);
    void add(double* [4][4], double* [4][4], double* [4][4]); 
    
    #endif
    

    Matrix.cpp

    #include "stdafx.h"
    
    void mul(double* m1[4][4], double* m2[4][4], double* [4][4])
    {
    
    }
    
    void add(double* m1[4][4], double* m2[4][4], double* [4][4])
    {
    
    }
    

    Programm

    ...
    
    double m1[4][4]={1}, m2[4][4]={1}, res[4][4]={1};
    
    		system("cls");
    
    		printf("Matrix\
                  \n======\n\n");
    
    		mul( (double*(*)[4])m1 , (double*(*)[4])m2 , (double*(*)[4])res);        
    
    ...
    

    So da funktioniert das von KA aber die Werte stimmen halt nicht



  • camper schrieb:

    pad8626 schrieb:

    Hi ich hoffe das ist die richtige Kategorie für das Thema.

    Ich hab zwei vorgegebene Funktionköpfe:

    ```cpp
    void mul(double
    m1[4][4], double
    m2[4][4], double* result[4][4])

    void add(double* m1[4][4], double* m2[4][4], double* result[4][4])

    **  
    ich soll also aus meinem Hauptprgoramm drei 2D Felder übergeben aber ich bekomm es einfach net hin. Wie würde ein Bsp. aussehen wenn ich z.B:  
      
    
    ```cpp
    double m1[4][4], m2[4][4], res[4][4];
    

    NICHT VORGEGEBEN

    die drei Felder hab und Sie an die Funktion "mul" übergeben will.

    Das geht nicht. Deine Variablen sind 2-dimensionale Arrays mit dem Elementtyp double. Die Funktionen erwarten dagegen 2-dimensionale Arrays (genauer: Pointer auf eindimensionale Arrays, aber dieser Unterschied spielt hier keine Rolle) mit dem Elementtyp Pointer auf double. Die Aufgabe muss hier scheitern, und kein noch so kreatives und sinnfreies Herumcasten wird daran etwas ändern.

    Du siehst ja was vorgegeben ist das muss ja irgendwie funktionieren vielleicht muss man dann halt die Felder anders deklarieren aber wie??

    Jetzt weiß ich gar net mehr weiter



  • pad8626 schrieb:

    Du siehst ja was vorgegeben ist das muss ja irgendwie funktionieren vielleicht muss man dann halt die Felder anders deklarieren aber wie??

    Hab ich doch gesagt:

    //Deklaration
    double *m1[4], *m2[4], *res[4];
    
    //Aufruf
    mul(&m1, &m2, &res);
    


  • kompilieren tut er es aber ich kann nur die ersten vier Werte beschreiben. Aber die restlichen 12 da sagt er zu viele Initialisierungen.


  • Mod

    pad8626 schrieb:

    camper schrieb:

    pad8626 schrieb:

    Hi ich hoffe das ist die richtige Kategorie für das Thema.

    Ich hab zwei vorgegebene Funktionköpfe:

    ```cpp
    void mul(double
    m1[4][4], double
    m2[4][4], double* result[4][4])

    void add(double* m1[4][4], double* m2[4][4], double* result[4][4])

    **  
    ich soll also aus meinem Hauptprgoramm drei 2D Felder übergeben aber ich bekomm es einfach net hin. Wie würde ein Bsp. aussehen wenn ich z.B:  
      
    
    ```cpp
    double m1[4][4], m2[4][4], res[4][4];
    

    NICHT VORGEGEBEN

    die drei Felder hab und Sie an die Funktion "mul" übergeben will.

    Das geht nicht. Deine Variablen sind 2-dimensionale Arrays mit dem Elementtyp double. Die Funktionen erwarten dagegen 2-dimensionale Arrays (genauer: Pointer auf eindimensionale Arrays, aber dieser Unterschied spielt hier keine Rolle) mit dem Elementtyp Pointer auf double. Die Aufgabe muss hier scheitern, und kein noch so kreatives und sinnfreies Herumcasten wird daran etwas ändern.

    Du siehst ja was vorgegeben ist das muss ja irgendwie funktionieren vielleicht muss man dann halt die Felder anders deklarieren aber wie??

    Jetzt weiß ich gar net mehr weiter

    Es gibt mehrere Möglichkeiten. Letzlich hängt das davon ab, welche Anforderungen die Funktionen an ihre Parameter stellen. Eine denkbare Variante ist jedenfalls, für den Funktionsaufruf ein Hilfsarray p mit dem korrekten Typ für die Funktion (also mit dem Elementtyp Pointer auf double) zu kreieren, und zwar mit dem Inhalt, dass für jedes p[i][j] gilt:
    p[i][j] == &a[i][j] (a ist das Ausgangsarray)
    Dies wird für alle Parameter der Funktion durchgeführt und diese dann mit den 3 Hilfsarrays aufgerufen.
    also

    const int N = 4, M = 4;
    void mul_helper(double m1[N][M], double m2[N][M], double result[N][M])
    // oder auch void mul_helper(double (&m1)[N][M], double (&m2)[N][M], double (&result)[N][M]), wenn man etwas ausdrücklicher formulieren will
    {
        double* pm1[N][M], *pm2[N][M], *presult[N][M]:
        for ( int i = 0; i < N; ++i )
            for ( int j = 0; j < M; ++j )
            {
                pm1[i][j] = &m1[i][j];
                pm2[i][j] = &m2[i][j];
                presult[i][j] = &mresult[i][j];
            }
        mul( pm1, pm2, presult );
    }
    

    schorsch code schrieb:

    pad8626 schrieb:

    Du siehst ja was vorgegeben ist das muss ja irgendwie funktionieren vielleicht muss man dann halt die Felder anders deklarieren aber wie??

    Hab ich doch gesagt:

    //Deklaration
    double *m1[4], *m2[4], *res[4];
    
    //Aufruf
    mul(&m1, &m2, &res);
    

    syntaktisch ja, inhaltlich blödsinn. denn hier hast du ja von vornherein nur ein eindimensionales array. die fehlende zweite dimension wird der compiler hoffentlich mit einem segfault belohnen.



  • glaub kaum das unser prof das unbedingt wollte das wir noch sone zusatz Funktion schreiben sonst hätte er das mit in die Aufgabe geschrieben



  • camper schrieb:

    schorsch code schrieb:

    pad8626 schrieb:

    Du siehst ja was vorgegeben ist das muss ja irgendwie funktionieren vielleicht muss man dann halt die Felder anders deklarieren aber wie??

    Hab ich doch gesagt:

    //Deklaration
    double *m1[4], *m2[4], *res[4];
    
    //Aufruf
    mul(&m1, &m2, &res);
    

    syntaktisch ja, inhaltlich blödsinn. denn hier hast du ja von vornherein nur ein eindimensionales array. die fehlende zweite dimension wird der compiler hoffentlich mit einem segfault belohnen.

    Oh, da bin ich aber überrascht 😮
    Warum sollte das folgende Beispiel mit einem segfault belohnt werden 😕

    #include <iostream>
    using namespace std;
    
    void print_matrix(double *m[4][4])
    {
        for(int i = 0; i < 4; ++i)
        {
            for(int j = 0; j < 4; ++j)
                cout << (*m)[i][j] << " ";
            cout << "\n";
        }
    }
    
    int main()
    {
        double *m1[4];
    
        //Speicher für m1 reservieren
        for(int i = 0; i < 4; ++i)
            m1[i] = new double[4];
    
        //m1 initialisieren    
        for(int i = 0; i < 4; ++i)
            for(int j = 0; j < 4; ++j)
                m1[i][j] = .5;
    
        print_matrix(&m1);
    
        //Speicher von m1 freigeben
        for(int i = 0; i < 4; ++i)
            delete [] m1[i];
    }
    

Log in to reply