Brauche Hilfe error C2109 :/



  • Hallo Leute ich bin völliger Anfänger im Programmieren und versuche mich gerade an einem Text basierendem Game in der Programmiersprache C.Leider wird mir beim Debuggen des folgenden Quellcodes immer ein error C2109 in der markierten Zeile angezeigt.Könnt ihr mir helfen ? :

    #include "stdafx.h"
    #include <stdio.h>
    #include <stdlib.h>

    //Prototypen
    void SpielfeldAusgabe(char *Spielfeld, int *FeldZustand);
    void Bewegung();

    int main()
    {
    char Spielfeld[10][10][3],Zug;
    int FeldZustand[100] = { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
    int PosX = 1, PosY = 1, i,k;

    //Feldzustände zuordnen
    for(i=0;i<10;i++) {
    for(k=0;k<10;k++) {
    Spielfeld[i][k][0] = 32;
    }
    }

    for(i=0;i<10;i++) {
    for(k=0;k<10;k++) {
    Spielfeld[i][k][1] = 124;
    }
    }

    for(i=0;i<10;i++) {
    for(k=0;k<10;k++) {
    Spielfeld[i][k][2] = 83;
    }
    }

    //Setzen des Spielers

    Spielfeld[PosY][PosX][0,1,2] = 83 ;

    //Hauptteil
    do {
    SpielfeldAusgabe(&Spielfeld[0][0][0],&FeldZustand[0]);
    printf("\nZug [w hoch, a links, s runter, d rechts]: ");
    scanf("%c", &Zug);
    Bewegung();
    } while ( Zug != 'x' );

    return 0;
    }

    void SpielfeldAusgabe(char *Spielfeld, int *FeldZustand) {

    printf("\n");
    system("cls");

    int j,l,Zustand = 0;

    // Schleife für Zeilen, Y-Achse
    for(j=0; j<10; j++) {
    // Schleife für Spalten, X-Achse
    for(l=0; l<10; l++) {
    printf("%c", *(Spielfeld[j][l][FeldZustand[Zustand]]));

    IN DER HIERDRÜBER LIEGENDEN ZEILE ^^ .

    Zustand++;
    }
    printf("\n");
    }
    }

    void Bewegung() {

    }



  • Und was genau wundert dich daran?



  • Ich möchte wissen warum der Fehler dort entsteht und wie man ihn beheben könnte ^^ Der Fehler besagt ja dass ich auf eine Variable verwiesen habe die kein Array ist , aber das ist sie doch ?



  • Dann wollen wir das mal aufdröseln.

    Dein Ausdruck lautet Spielfeld[j][l][FeldZustand[Zustand]] . Schauen wir uns die einzelnen Teilausdrücke nacheinander an.

    Die Variable Spielfeld hat den Typ char*.

    Der Ausdruck Spielfeld[j] hat dann den Typ char.

    Der Ausdruck Spielfeld[j][l] hat welchen Typ? Keinen, der [] Operator ist auf char nicht anwendbar, das ist ein Fehler.

    Jetzt irgendeine Idee, was das Problem sein könnte?



  • Also das die Variable Spielfeld den Typ char hat verstehe ich , hab ich ja so festgelegt. Aber wieso ist der Ausdruck Spielfeld[j] vom typ char und der Ausdruck [j][l] dann von garkeinem Typ ?
    Ne leider keine Idee ^^.



  • xxXLukas97Xxx schrieb:

    Also das die Variable Spielfeld den Typ char hat verstehe ich

    Schön, aber sie hat den Typ char* und nicht char. Hast du das übersehen oder willentlich ignoriert?



  • Oh das hab ich übersehen. Was ist denn der Typ char* ? Mir ist nur char ohne das * bekannt ^^.


  • Mod

    xxXLukas97Xxx schrieb:

    Oh das hab ich übersehen. Was ist denn der Typ char* ? Mir ist nur char ohne das * bekannt ^^.

    Zeiger auf char. Zeiger sind ein ganz wichtiges Thema in C, das man kennen muss. Kommt bestimmt bald in deinem Lehrbuch. Was jedoch ungewöhnlich ist, dass du selber reichlich Pointer in deinem Code benutzt. Da bist du ja selber wohl nicht drauf gekommen.



  • Das Thema Zeiger in dem Buch habe ich schon durchgenommen. Ich war nur verwirrt weil ich das sich für mich so angehört hat als wäre char* ein ganz eigener Datentyp um eine Variable zu deklarieren. Wie man einen Zeiger erstellt und wie er funktioniert glaube ich verstanden zu haben. ^^



  • Es ist ja auch ein eigener Datentyp, nämlich "Zeiger auf char".



  • Ja stimmt auch wieder :D. Ist bestimmt lustig für Sie einem Änfanger beim failen zuzugucken 😛 🙂 Also gut habe jtz zumindest verstanden was sie gemeint haben , aber was ist daran jtz das Problem ? Das hab ich immer noch nicht verstanden.



  • xxXLukas97Xxx schrieb:

    Ja stimmt auch wieder :D. Ist bestimmt lustig für Sie einem Änfanger beim failen zuzugucken 😛 🙂

    Nö, das Problem ist eher, deine Kenntnisse einzuschätzen, um eine passende Antwort zu geben. Jeder hier könnte dir die Lösung einfach hinschreiben, aber das hilft dir nicht.

    BTW Siezen tut man in Internetdiskussionen normalerweise nicht, manche könnten das sogar als Beleidigung auffassen.

    Also gut habe jtz zumindest verstanden was sie gemeint haben , aber was ist daran jtz das Problem ? Das hab ich immer noch nicht verstanden.

    OK, aber was hast du verstanden? Paar Testfragen, mach soweit du kommst.

    int array[10][10];
    int i, j, k;
    int *zeiger = &array[0][0];
    
    /* Sind die folgenden Ausdrücke korrekt, und wenn ja, welchen Typ haben sie? */
    array
    array[i]
    array[i][j]
    array[i][j][k]
    
    zeiger
    *zeiger
    **zeiger
    zeiger[i]
    zeiger[i][j]
    


  • Okay nicht Siezen ^^ Danke für den Hinweis 🙂
    Yay habs doch noch zum laufen gebracht indem ich alles in die main() gepackt hab 🙂 ( beste lösung ever .. nicht ! 😃 )
    mom mach jtz die aufgaben



  • int array[10][10];
    int i, j, k;
    int *zeiger = &array[0][0];
    
    /* Sind die folgenden Ausdrücke korrekt, und wenn ja, welchen Typ haben sie? */
    array //korrekt = int
    array[i] // nicht korrekt
    array[i][j] //korrekt int 
    array[i][j][k] //nicht korrekt
    
    zeiger //nicht korrekt
    *zeiger //korrekt = int 
    **zeiger //korrekt = int 
    zeiger[i] //nicht korrekt
    zeiger[i][j] //nicht korrekt
    

    wow hab grad gemerkt dass ich noch ziemlich unsicher bin , muss mir das auf jeden fall nochmal durchlesen ^^



  • xxXLukas97Xxx schrieb:

    int array[10][10];
    int i, j, k;
    int *zeiger = &array[0][0];
     
    /* Sind die folgenden Ausdrücke korrekt, und wenn ja, welchen Typ haben sie? */
    array //korrekt = int // korrekt int**
    array[i] // nicht korrekt // korrekt int*
    array[i][j] //korrekt int
    array[i][j][k] //nicht korrekt
     
    zeiger //nicht korrekt // korrekt int*
    *zeiger //korrekt = int // korrekt int
    **zeiger //korrekt = int  // nicht korrekt
    zeiger[i] //nicht korrekt // korrekt int
    zeiger[i][j] //nicht korrekt // nicht korrekt
    

  • Mod

    Nathan schrieb:

    xxXLukas97Xxx schrieb:

    int array[10][10];
    int i, j, k;
    int *zeiger = &array[0][0];
     
    /* Sind die folgenden Ausdrücke korrekt, und wenn ja, welchen Typ haben sie? */
    array //korrekt = int // korrekt int**
    array[i] // nicht korrekt // korrekt int*
    array[i][j] //korrekt int
    array[i][j][k] //nicht korrekt
     
    zeiger //nicht korrekt // korrekt int*
    *zeiger //korrekt = int // korrekt int
    **zeiger //korrekt = int  // nicht korrekt
    zeiger[i] //nicht korrekt // korrekt int
    zeiger[i][j] //nicht korrekt // nicht korrekt
    

    Jetzt löst du ihm die Aufgabe, aber das auch noch falsch.



  • SeppJ schrieb:

    Nathan schrieb:

    xxXLukas97Xxx schrieb:

    int array[10][10];
    int i, j, k;
    int *zeiger = &array[0][0];
     
    /* Sind die folgenden Ausdrücke korrekt, und wenn ja, welchen Typ haben sie? */
    array //korrekt = int // korrekt int**
    array[i] // nicht korrekt // korrekt int*
    array[i][j] //korrekt int
    array[i][j][k] //nicht korrekt
     
    zeiger //nicht korrekt // korrekt int*
    *zeiger //korrekt = int // korrekt int
    **zeiger //korrekt = int  // nicht korrekt
    zeiger[i] //nicht korrekt // korrekt int
    zeiger[i][j] //nicht korrekt // nicht korrekt
    

    Jetzt löst du ihm die Aufgabe, aber das auch noch falsch.

    Soll ich Dir ein Buch zeigen, wo das genau so steht? 😃

    Naja, array ist weiterhin int[10][10] und nicht int**.
    Kann man prüfen, indem man sizeof(array) ausgibt.



  • xxXLukas97Xxx schrieb:

    int array[10][10];
    int i, j, k;
    int *zeiger = &array[0][0];
     
    /* Sind die folgenden Ausdrücke korrekt, und wenn ja, welchen Typ haben sie? */
    array //korrekt = int           // falsch, array hat den Typ int[10][10]
    array[i] // nicht korrekt       // falsch, es ist korrekt und array[i] hat den Typ int[10]
    array[i][j] //korrekt int       // richtig
    array[i][j][k] //nicht korrekt  // richtig
     
    zeiger //nicht korrekt          // falsch, es ist korrekt und zeiger hat den Typ int*
    *zeiger //korrekt = int         // richtig
    **zeiger //korrekt = int        // falsch, der Ausdruck ist nicht korrekt
    zeiger[i] //nicht korrekt       // falsch
    zeiger[i][j] //nicht korrekt    // richtig
    

    Keine besonders gute Ausbeute 😉

    Drei Antworten wundern mich ein bisschen. Die ersten beiden (array und array[i]) sowie die siebte (**zeiger). Irgendwie deutet das auch darauf hin, was du bei deinem ursprünglichen Programm falsch gemacht hast.

    Also erstens lassen sich Ausdrücke immer(*) verstehen, indem man ihre Teilausdrücke analysiert. Der Ausdruck array[i][j] ist beispielsweise zu verstehen, indem man ihn als ((ausdruck)[i])[j] schreibt und die Ebenen von innen nach außen untersucht:
    array -- ist ein Array mit 10 Elementen. Die Elemente sind wieder Arrays mit 10 Elementen (die jeweils ein int sind). Mehrdimensionale Arrays werden durch Verschachtelung von eindimensionalen Arrays dargestellt.

    Was kann ich mit einem Array machen? Auf Elemente zugreifen.

    array[i] -- ist das i-te Element von array. Also ist das ein Array mit 10 int-Elementen.

    Ich kann also wieder auf Elemente zugreifen.

    (array[i])[j] -- ist das j-te Element vom i-ten Element von array. (Die Klammern kann und sollte man natürlich weglassen.)

    Nächste Ebene:

    (array[i][j])[k] -- ergibt keinen Sinn: Das j-te Element von i-ten Element von array ist ein int und nicht selbst ein Array, man kann darauf nicht nochmal einen Indexzugriff durchführen.

    Im Prinzip der gleiche Denkfehler ist auch bei deiner Antwort zu **zeiger gegeben. Wenn zeiger ein Zeiger auf ein int ist und *zeiger ein int (was du richtig erkannt hast), dann ist *(*zeiger) -- ich schreib mal wieder überflüssige Klammern drumherum -- also der Versuch, einen int zu nehmen und so zu tun, als sei es ein Zeiger, und das geht natürlich nicht.

    Was du außerdem wissen musst, ist der Zusammenhang zwischen Zeigern und Arrays. Ein Zeiger ist ein Objekt, das die Adresse eines Objekts seines Zieltyps enthält (bzw. enthalten kann). Ein Array ist eine Ansammlung von Elementen, die hintereinander im Speicher liegen. Die beiden Sachen haben direkt nichts miteinander zu tun, aber: Fast immer, wenn du ein Array in einem Ausdruck benutzt, wird es als Zeiger auf sein erstes Element angesehen. Und, so intuitiv der Indexzugriff mit [] aussehen mag, er ist in Wirklichkeit über Zeigerarithmetik definiert. Der Ausdruck zeiger[i] bedeutetnichts anderes als *(zeiger+i) , und array[i] bedeutet nichts anderes als *((&array[0])+i) . Man braucht eine Weile, um sich daran zu gewöhnen. Manche (siehe z.B. Anwort von Nathan, sogar Buchautoren) lassen sich auch davon täuschen und glauben dann, dass Arrays und Zeiger irgendwie das gleiche wären. Mit dieser Annahme kommt man erstaunlich weit, allerdings ist man so nicht in der Lage, mehrdimensionale Arrays zu verstehen.

    Fußnote (*): Jedenfalls sollte es so sein, mir fällt in C auch kein Gegenbeispiel ein.



  • Bashar schrieb:

    Keine besonders gute Ausbeute 😉

    Haha ja hab ich gemerkt 🙂 Muss das alles nochmal wiederholen.Aber mit deiner Antwort da, sollte mir das aber schon etwas leichter fallen , danke 🙂
    Hab jtz das ganze Spiel ( also soweit wie ich schon bin ) erstmal ohne Zeiger gemacht und sofort klappt alles 😃 Kannst dir es ja mal angucken wenn du willst 😉 :

    #include "stdafx.h" 
    #include <stdio.h> 
    #include <stdlib.h> 
    
    char Spielfeld[10][10][3], Zug;
    int FeldZustand[100] = { 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,2,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1};
    int PosX = 2, PosY = 2;
    
    //Prototypen 
    void SpielfeldAusgabe(); 
    void Bewegung(); 
    void FeldzuständeZuordnen();
    void SpielerBerührung();
    
    int main() 
    { 
    	//Hauptteil 
        do { 
    		FeldzuständeZuordnen();
            SpielfeldAusgabe(); 
            printf("\nZug w (hoch), a (links), s (runter), d (rechts): "); 
            scanf("%c", &Zug); 
            Bewegung(); 
        } while ( Zug != 'x' ); 
    
        return 0; 
    } 
    
    void SpielfeldAusgabe() { 
    
        printf("\n"); 
        system("cls"); 
    
       int j, l, Zustand = 0; 
    
        // Schleife für Zeilen, Y-Achse 
        for(j=0; j<10; j++) { 
            // Schleife für Spalten, X-Achse 
            for(l=0; l<10; l++) { 
                printf("%c", Spielfeld[j][l][FeldZustand[Zustand]]); 
                Zustand++; 
            } 
            printf("\n"); 
        } 
    } 
    
    void Bewegung() { 
    
    	//Neue Position bestimmen
    
    	switch(Zug) {
    	case 'w' : PosY--;break;
    	case 's' : PosY++;break;
    	case 'a' : PosX--;break;
    	case 'd' : PosX++;break; }
    
    	SpielerBerührung();
    }
    
    void FeldzuständeZuordnen() {
    
    	int i,k; 
    
      //Feldzustände zuordnen 
        for(i=0;i<10;i++) { 
            for(k=0;k<10;k++) { 
            Spielfeld[i][k][0] = 32; 
            } 
        } 
    
        for(i=0;i<10;i++) { 
            for(k=0;k<10;k++) { 
            Spielfeld[i][k][1] = 124; 
            } 
        } 
    
        for(i=0;i<10;i++) { 
            for(k=0;k<10;k++) { 
            Spielfeld[i][k][2] = 36; 
            } 
        } 
    
    	Spielfeld[PosY][PosX][0] = 83 ; 
    	Spielfeld[PosY][PosX][1] = 83 ; 
    	Spielfeld[PosY][PosX][2] = 83 ;
    }
    void SpielerBerührung() {
    
    	//Spielfeldrand Berührung
    
        if (PosY < 1) PosY = ++PosY; 
    	if (PosY > 8) PosY = --PosY;
    	if (PosX < 1) PosX = ++PosX;
    	if (PosX > 8) PosX = --PosX;
    
    	}
    


  • volkard schrieb:

    SeppJ schrieb:

    Nathan schrieb:

    xxXLukas97Xxx schrieb:

    int array[10][10];
    int i, j, k;
    int *zeiger = &array[0][0];
     
    /* Sind die folgenden Ausdrücke korrekt, und wenn ja, welchen Typ haben sie? */
    array //korrekt = int // korrekt int**
    array[i] // nicht korrekt // korrekt int*
    array[i][j] //korrekt int
    array[i][j][k] //nicht korrekt
     
    zeiger //nicht korrekt // korrekt int*
    *zeiger //korrekt = int // korrekt int
    **zeiger //korrekt = int  // nicht korrekt
    zeiger[i] //nicht korrekt // korrekt int
    zeiger[i][j] //nicht korrekt // nicht korrekt
    

    Jetzt löst du ihm die Aufgabe, aber das auch noch falsch.

    Soll ich Dir ein Buch zeigen, wo das genau so steht? 😃

    Naja, array ist weiterhin int[10][10] und nicht int**.
    Kann man prüfen, indem man sizeof(array) ausgibt.

    Sehe das erst jetzt:
    Ich wundere mich auch gerade, was ich da für einen Murks geschrieben habe.
    Klar ist der Typ von int array[10][10] int[10][10].
    Ich sollte vielleicht lesen, was ich schreibe.


Log in to reply