array übergeben

Von: , 25.06.2011 11:29 Uhr

Liebe/-r Experte/-in,

ich bin gerade dabei Schiffe versenken in C zu programmieren. Dafür habe ich zunächst einmal sämtliche schleifen etc in die main geschrieben, um zu sehen, ob das ganze so funktioniert wie ich mir das gedacht habe. Das tut es!
Anschließend habe ich angefangen mit dem Erzeugen von Nebenfunktionen das ganze ein wenig übersichtlicher zu gestalten. Dabei ist folgendes Problem aufgetretten:
Nach der Eingabe der Schiffe (Nebenfunktion) funktioniert das ganze noch. Bei der Schussabfrage(Nebenfunktion) erkennt er jedoch nicht mehr, dass eine Schiff in das Array gesetzt wurde. Das Array habe ich dabei in einer eigenen Header-Datei definiert, welche sowohl in der main als auch in sämtlichen nebenfunktionen eingebunden ist.

Woran kann das liegen? Ich bin für jeden Ansatz dankbar. Da ich aber noch Anfänger bin traue ich mich noch nicht so ganz an Strukturen und Pointer ran... geht das auch ohne diese sachen zu lösen?
gern poste ich auch noch mal den quellcode falls das weiter hilft

vielen Dank im Vorraus
Student90

14 Antworten zu dieser Frage

  1. Antwort von nach einer Stunde 0 hilfreich
    Re: array übergeben

    Hi,

    vorweg wäre es wichtig zu wissen, ob du nun wirklich strikt in C schreibst, oder in C/C++. Mit C++ kannst du dir einige Sachen nämlich stark vereinfachen.

    Bei programmiertechnischen Problemen ist helfen ohne den Quellcode zu kennen immer sehr schwierig, zumal ich mit deiner Beschreibung ehrlichgesagt noch nicht viel anfangen kann ;)

    Was ich aber schonmal sagen kann:
    Wenn du C-Arrays übergeben willst, kommst du um Pointer nicht herum. Alle Arrayelemente werden im Speicher direkt hintereinander abgelegt. Der Variablennamen, den du für dein Array ausgesucht hast, ist im Grunde bloß ein Pointer auf das erste Element des Arrays, und mit dem Array-Index wanderst du dann von diesem Pointer aus entsprechend viele Bytes im Speicher weiter. Daher kannst du auch eine Zugriffsverletzung hervorrufen, in dem du einen höheren Index angibst, als Arrayelemente vorhanden sind.

    Also:
    Einmal den Quellcode posten, zumindest die Stellen, die dir Probleme bereiten, sofern der Rest dafür irrelevant ist.

    MfG Subsurf

    • Antwort von nach 6 Stunden 0 hilfreich
      Re^2: array übergeben

      Hey!
      Danke zunächst ein mal für die schnelle Antwort. Das Ganze sollte wirklich in C geschehen und nicht in C++.
      Gern nehm ich dein Angebot an und kopiere dir mal die(meiner Meinung nach) relevanten Teile hier rein.
      aber das wird wirklich etwas mehr... =)

      Dazu dann vielleich auch noch einge erklärende Worte: Zunächst weiß ich, dass mein Programmierstil nicht besonders gut ist. Bitte reiß mir deswegen nicht gleich den Kopf ab. Wie gesagt bin mehr oder weniger blutiger Anfänger und freue mich, dass ich überhaupt soweit gekommen bin.
      Die Eingabe besteht aus einer while-schleife und einen riesigen switch. Die Fälle sind jedoch alle gleich aufgebaut und ahst du einen verstanden (was dir nicht schwer fallen sollte ;)) hast du alle verstanden. Zum Ende lasse ich mir noch einmal das Feld ausgeben, um zu testen ob die SChiffe wirklich drin stehen. (Ja )
      Gleiches mache ich als erstes in der Schussabfrage. Hier ist dann schon nichts mehr von Schiffen zu sehen.
      Liegt das daran, dass das ganze bei der Eingabe nur lokal geschieht? (ich war der Meinung, wenn ich in eine Header-Datei mit einer Variablen einbinde, wirkt das wie eine globale Variable?
      Die Feld-Header-Datei:

      static int feld[11][27];     // Feld für die Eingabe der Boote
      static int a_feld[11][27];  // Feld für die Eingabe der Schüsse
      

      Die main:
      //eigene Headerdateien
      #include "feldausgabe.h" // um die verschiedenen Felder auszugeben
      #include "feld.h" //Feld als globale Variable definieren
      #include "Schussabfrage.h" //Abfrage der Schüsse
      #include "Schiffe.h" //Anzeigen der Auswahlmöglichkeiten
      #include "Eingabe.h"
      #include "start.h" //Ausgabe des Startbildschirms
      int _tmain(int argc, _TCHAR* argv[])
      { int x,y;
      start(); //Ausgabe des Startbildschirms
      feldausgabe(); //Feldausgabe
      Schiffe (); //Ausgabe der Eingabemöglichkeiten
      Eingabe ();
      system("pause");
      clear(); // Löschen des Bildschirms
      feldausgabe2(); 
      schussabfrage();//Abfrage der Schüsse
      system("pause");
      return 0;
      }
      


      Die Eingabe-Funktion: (der Übersichtlichkeit habe ich nur die ersten beiden case gepostet)
      #include "stdafx.h"
      #include "stdlib.h"
      #include "stdio.h"
      #include "borland.h" 
      #include "feld.h"
      #include "lösche.h"
      #include "Eingabe.h"
      #include "feldausgabe.h"
      int Eingabe()
      {
      int welches=0, setzen=0;
      int posx1=0, posy1=0, hilf1=0, hilf2=0, hilf3=0;
      int x,y;
      do
      {
      gotoxy(35,10); //Springe rechts neben das Speilfeld
      printf("welches Schiffe mochten sie setzen?"); 
      scanf("%c",&hilf3);
      welches = (int) (hilf3-48);
      fflush(stdin); //Löschen des Eingabe Puffers
      gotoxy(35,11); //springe rechts neben den Bildschirm
      printf("welcher Buchstabe?"); // Uboot waagerecht 3 Felder´groß
      scanf("%c",&hilf1);
      fflush(stdin); //Löschen des Eingabe Puffers
      posx1 = (int) hilf1; //Umwandlung von char zu int
      gotoxy(35,12); // springe rechts neben das Spielfeld
      printf("Welche Nummer?");
      scanf("%c",&hilf2);
      posy1= (int) (hilf2-48);
      fflush(stdin); //Löschen des Eingabe Puffers
      switch(welches) // Schalter nach Auswahl des Bootes
      {
      case 1: if (feld [posx1-64][posy1+1] == '#' || //Uboot waagerecht 3 Felder 
      feld [posx1-63][posy1+1] == '#' || // Überprüfen ob eins der Ausgewählten Felder belegt ist
      feld [posx1-62][posy1+1] == '#') 
      {
      gotoxy(35,16);
      printf("Feld bereists belegt!! Neuses Boot und Feld aussuchen");
      }
      else if (posx1>=65 && posx1<=88) //Überprüfen ob das Boot innerhalb des Spielfeldes gesetzt wird
      { // Setzen des Bootes
      feld [posx1-64][posy1+1] = '#';
      feld [posx1-63][posy1+1] = '#';
      feld [posx1-62][posy1+1] = '#';
      gotoxy(posx1+1-64,posy1+10+1); //springe an die gewählte Position
      printf("%c",feld [posx1-64][posy1+1]); //Bildschirmausgabe das das Boot gesetzt ist 
      gotoxy(posx1+1-63,posy1+10+1); //springe an die gewählte Position
      printf("%c",feld [posx1-63][posy1+1]); //Bildschirmausgabe das das Boot gesetzt ist 
      gotoxy(posx1+1-62,posy1+10+1); //springe an die gewählte Position
      printf("%c",feld [posx1-62][posy1+1]); //Bildschirmausgabe das das Boot gesetzt ist 
      }
      else
      {
      gotoxy(35,16);
      printf("Schiff liegt außerhalb des Spielfeldes!!");
      }
      break;
      case 2 : if (feld[posx1-64][posy1+1] == '#'||
      feld [posx1-63][posy1+1] == '#') //Überprüfen ob das Ausgewählte Feld schon belegt ist
      {
      gotoxy(35,16);
      printf("error!! Neues Boot und Feld auswaelen\n");
      }
      else if (posx1>=65 && posx1<=89) //Setzen des Bootes
      {
      feld [posx1-64][posy1+1] = '#';
      feld [posx1-63][posy1+1] = '#';
      gotoxy(posx1+1-64,posy1+10+1); //springe an die gewählte Position
      printf("%c",feld [posx1-64][posy1+1]); //Bildschirmausgabe das das Boot gesetzt ist 
      gotoxy(posx1+1-63,posy1+10+1); //springe an die gewählte Position
      printf("%c",feld [posx1-63][posy1+1]); //Bildschirmausgabe das das Boot gesetzt ist 
      }
      else 
      { 
      gotoxy(35,16);
      printf("Schiff liegt außerhalb des Spielfeldes!!");
      }
      break;
      printf("Moechten Sie weitere Schiffe setzen?"); //Bedingung while-Schleife
      gotoxy(35,14); //springe an diese Position
      printf("ja (j) oder nein(n)?"); 
      scanf("%c",&setzen); 
      fflush(stdin); //Löschen des Eingabe Puffers
      if (setzen != 'n') 
      { 
      löschen(); //Löschen der vorhergehenden Auswahl und Fehlermeldungen
      }
      }
      while (setzen != 'n');
      for (x=1; x<=10; x++) //Ausgabe der Zeichen im Array als Überprüfung
      {
      for (y=1; y<=26; y++) 
      { 
      {
      gotoxy(y+1,x+10);
      printf("%c",feld[y][x]);
      }
      }
      printf("\n");
      }
      return 0;
      }
      


      Die Schussabfrage:
      #include "stdafx.h"
      #include "stdlib.h"
      #include "stdio.h"
      #include "borland.h" // für gotoxy-Befehle
      //eigene Headerdateien
      #include "feld.h" //Feld als globale Variable definieren
      #include "lösche2.h"
      int schussabfrage ()
      {
      int posx=0,posy=0,hilf=0,hilf2=0;
      int x,y;
      int weiter=0;
      float i=0, t=0;
      for (x=1; x<=10; x++) //Ausgabe der Zeichen im Array als Überprüfung
      {
      for (y=1; y<=26; y++) 
      { 
      {
      gotoxy(y+1,x+10);
      printf("%c",feld[x][y]);
      }
      }
      printf("\n");
      }
      do 
      { 
      gotoxy(35,11);
      printf("welcher Buchstabe?"); //Abfrage des Schusses
      scanf("%c",&hilf); 
      fflush(stdin); //Löschen des Eingabe Puffers
      posx = (int) hilf; //Umwandlung in einen int-Wert 
      gotoxy(35,12); 
      printf("Welche Nummer?"); //Abfrage y-wert
      scanf("%i",&posy); 
      fflush(stdin); //Löschen des Eingabe Puffers
      //posy = (int) hilf2; //Umwandlung in einen int-Wert
      if (a_feld[posx-64][posy+1] == 'o' ||a_feld[posx-64][posy+1] == 'x')
      {
      gotoxy (35,15);
      printf("Feld wurde bereits beschossen!");
      }
      if ((posx>=65 && posx<=90)&&(posy>=0 && posy<=9)) //gültiger Schuss
      if (feld[posx-64][posy+1] == '#') //Vergleich mit gesetzten schiffe 
      {
      a_feld[posx-64][posy+1] = 'x'; //Treffer
      t++; //Treffer+1
      i++; //Schüsse +1
      }
      else 
      {
      a_feld[posx-64][posy+1] = 'o'; //kein Treffer
      i++; //Schüsse+1
      }
      else
      {
      gotoxy (35,15);
      printf("ungültiger Schuss");
      }
      gotoxy(posx+1-64,posy+10+1); //an die gewählte Position springen
      printf("%c",a_feld[posx-64][posy+1]); //'x' oder 'o' auf den Bildschirm ausgeben
      gotoxy(35,13); //immer an die gleiche stelle springen, damit feld "unbeschädigt" bleibt
      printf("brechen sie das suchen mit x ab!"); //Bedingung für die while-schleife
      scanf("%c", &weiter); 
      fflush(stdin); //Löschen des Eingabepuffers
      if (weiter != 'x');
      { 
      löschen2(); //Löschen der vorherigen Auswahl
      }
      }
      while (weiter != 'x');
      for (x=1; x<=10; x++) //Ausgabe der Zeichen im Array
      { //Anzeigen der Versteckten Schiffe und der Schüsse
      for (y=1; y<=26; y++) 
      { 
      if (feld[y][x] == '#' && a_feld[y][x] != 'x')
      {
      gotoxy(y+1,x+10);
      printf("%c",feld[y][x]);
      }
      }
      printf("\n");
      }
      gotoxy(35,17);
      printf("Trefferquote:%.2f", (t/i)*100); //Berechnung derr Trefferquote
      return 0;
      }
      



      FAlls du dir das wirklich angeguckt hast, wäre ich dir sehr dankbar!!!!Auch für tipps und Ansätze bin ich jederzeit offen!!
      MfG
      Student90

  2. Antwort von nach 2 Stunden 0 hilfreich
    Re: array übergeben

    Hallo Student 90,

    ein Array stellt (wie übrigens auch eine Struktur) eine Ansammlung von Werten dar, die im Speicher hintereinander abgelegt werden. Um auf die Elemente zuzugreifen, merkt sich dein Programm immer den Anfang vom Array und zählt für alle anderen Elemente vom Anfang aus durch. Um das ganze abzukürzen: Indem du ein Array verwendest, arbeitest du bereits mit einem Pointer/Zeiger.

    Beispiel:
    int myArray[5] = { 0, 1, 2, 3, 4};
    int *myPointer = myArray;

    Ein Pointer ist eine Variable die für gewöhnlich auf etwas zeigt. Um zu zeigen dass sie gerade auf nichts zeigt, kann man sie auf NULL setzten: myPointer = NULL;

    Möchte man ein Array an eine Funktion übergeben, übergibt man zwangsläufig den Pointer.

    Kann so aussehen:

    void main(){
    /*initialisiert erstes Array-Element mit 0, alle anderen werden nun auf den Standartwert (ebenfalls 0) gesetzt.*/
    int myArray[5] = {0};

    myArray[0] = 1; //erstes Element beinhaltet nun den Wert 1
    printFirstArrayElementA(myArray);
    printFirstArrayElementA(myArray);
    }

    void printFirstArrayElementA(int *anArray){
    printf("Funktion A liefert: %i\n", *(anArray+0));
    }

    void printFirstArrayElementB(int anArray[]){
    printf("Funktion B liefert: %i\n", anArray[0]);
    }

    Die Funktionen printFirstArrayElementA und printFirstArrayElementB sind identisch und stellen lediglich verschiedene Schreibweisen dar.

    Zusätzlicher Hinweis: Hier im Quelltext rufe ich erst die main() auf und schreibe dann die Funktionen - der Übersicht halber. Dies ist jedoch eigentlich C++. In C müssen die Funktionen immer oberhalb ihres Aufrufes bereits defeniert sein.

    Keine Angst vor Zeigern, die sind auch nur Variablen, die halt auf was zeigen :). Ja, man kann mit Zeigern ungewollt Speicher überschreiben wie zum Beispiel so:

    myArray[5] = 1;

    Letztes Array-Element eines Arrays mit 5 Elementen, hat den Index [4].

    Unbekannten Speicher überschreiben kann böse sein, daher muss man hier aufpassen, was man tut. Das sollte dennoch kein Hindernis sein Zeiger (und damit Arrays) zu verwenden, denn darum wird man im maschinennahen C kaum kommen...

      • Antwort von nach 2 Stunden 0 hilfreich
        Re: array übergeben

        Hallo,

        Wenn du eine Variable in einer Header-Datei definierst bekommst du jedes mal eine eigenständige Kopie der Variable, wenn die Headerdatei eingefügt wird.

        Damit das nicht passiert musst du zum einen die Variable bzw. das Array im Headerfile als extern deklarieren (explizite deklaration), und zum anderen dann die eigentliche Deklaration in einem! Quellfile durchführen (implizite deklaration).
        In der englischsprachigen Wikipedia gibt es einen ganz guten Artikel dazu: http://en.wikipedia.org/wiki/External_variable

        Beispiel:

        func1.h:
        #ifndef __func1_h
        #define __func1_h
        extern int daten; /*explizite deklaration*/
        void func1();
        #endif

        func1.c:
        #include <stdio.h>
        #include "func.h"
        int daten=10; /*implizite deklaration (hier mit inititalisierung)*/
        void func1()
        { printf("%i\n", daten); }

        main.c:
        #include <stdio.h>
        #include "func.h"
        int main(int argc, char *argv[])
        {
        func1();
        daten=0;
        func1();
        return 0;
        }

      • Antwort von nach 3 Stunden 0 hilfreich
        Re: array übergeben

        Hallo Student90,

        ich kann hier leider nur mit dem Quellcode weiterhelfen, da ich nicht weiss wie und wo die Variablen/Arrays deklariert sind. Gerne schaue ich noch ueber den Quellcode rueber und gebe die Hinweise.

        Liebe Gruesse!

      • Antwort von nach 7 Stunden 0 hilfreich
        Re^2: array übergeben

        Hey!
        Danke zunächst ein mal für die schnelle Antwort.
        Gern nehm ich dein Angebot an und kopiere dir mal die(meiner Meinung nach) relevanten Teile hier rein.
        aber das wird wirklich etwas mehr... =)

        Dazu dann vielleich auch noch einge erklärende Worte: Zunächst weiß ich, dass mein Programmierstil nicht besonders gut ist. Bitte reiß mir deswegen nicht gleich den Kopf ab. Wie gesagt bin mehr oder weniger blutiger Anfänger und freue mich, dass ich überhaupt soweit gekommen bin.
        Die Eingabe besteht aus einer while-schleife und einen riesigen switch. Die Fälle sind jedoch alle gleich aufgebaut und ahst du einen verstanden (was dir nicht schwer fallen sollte ;)) hast du alle verstanden. Zum Ende lasse ich mir noch einmal das Feld ausgeben, um zu testen ob die SChiffe wirklich drin stehen. (Ja )
        Gleiches mache ich als erstes in der Schussabfrage. Hier ist dann schon nichts mehr von Schiffen zu sehen.
        Liegt das daran, dass das ganze bei der Eingabe nur lokal geschieht? (ich war der Meinung, wenn ich in eine Header-Datei mit einer Variablen einbinde, wirkt das wie eine globale Variable?
        Die Feld-Header-Datei:

        static int feld[11][27];     // Feld für die Eingabe der Boote
        static int a_feld[11][27];  // Feld für die Eingabe der Schüsse
        

        Die main:
        //eigene Headerdateien
        #include "feldausgabe.h" // um die verschiedenen Felder auszugeben
        #include "feld.h" //Feld als globale Variable definieren
        #include "Schussabfrage.h" //Abfrage der Schüsse
        #include "Schiffe.h" //Anzeigen der Auswahlmöglichkeiten
        #include "Eingabe.h"
        #include "start.h" //Ausgabe des Startbildschirms
        int _tmain(int argc, _TCHAR* argv[])
        { int x,y;
        start(); //Ausgabe des Startbildschirms
        feldausgabe(); //Feldausgabe
        Schiffe (); //Ausgabe der Eingabemöglichkeiten
        Eingabe ();
        system("pause");
        clear(); // Löschen des Bildschirms
        feldausgabe2(); 
        schussabfrage();//Abfrage der Schüsse
        system("pause");
        return 0;
        }
        


        Die Eingabe-Funktion: (der Übersichtlichkeit habe ich nur die ersten beiden case gepostet)
        #include "stdafx.h"
        #include "stdlib.h"
        #include "stdio.h"
        #include "borland.h" 
        #include "feld.h"
        #include "lösche.h"
        #include "Eingabe.h"
        #include "feldausgabe.h"
        int Eingabe()
        {
        int welches=0, setzen=0;
        int posx1=0, posy1=0, hilf1=0, hilf2=0, hilf3=0;
        int x,y;
        do
        {
        gotoxy(35,10); //Springe rechts neben das Speilfeld
        printf("welches Schiffe mochten sie setzen?"); 
        scanf("%c",&hilf3);
        welches = (int) (hilf3-48);
        fflush(stdin); //Löschen des Eingabe Puffers
        gotoxy(35,11); //springe rechts neben den Bildschirm
        printf("welcher Buchstabe?"); // Uboot waagerecht 3 Felder´groß
        scanf("%c",&hilf1);
        fflush(stdin); //Löschen des Eingabe Puffers
        posx1 = (int) hilf1; //Umwandlung von char zu int
        gotoxy(35,12); // springe rechts neben das Spielfeld
        printf("Welche Nummer?");
        scanf("%c",&hilf2);
        posy1= (int) (hilf2-48);
        fflush(stdin); //Löschen des Eingabe Puffers
        switch(welches) // Schalter nach Auswahl des Bootes
        {
        case 1: if (feld [posx1-64][posy1+1] == '#' || //Uboot waagerecht 3 Felder 
        feld [posx1-63][posy1+1] == '#' || // Überprüfen ob eins der Ausgewählten Felder belegt ist
        feld [posx1-62][posy1+1] == '#') 
        {
        gotoxy(35,16);
        printf("Feld bereists belegt!! Neuses Boot und Feld aussuchen");
        }
        else if (posx1>=65 && posx1<=88) //Überprüfen ob das Boot innerhalb des Spielfeldes gesetzt wird
        { // Setzen des Bootes
        feld [posx1-64][posy1+1] = '#';
        feld [posx1-63][posy1+1] = '#';
        feld [posx1-62][posy1+1] = '#';
        gotoxy(posx1+1-64,posy1+10+1); //springe an die gewählte Position
        printf("%c",feld [posx1-64][posy1+1]); //Bildschirmausgabe das das Boot gesetzt ist 
        gotoxy(posx1+1-63,posy1+10+1); //springe an die gewählte Position
        printf("%c",feld [posx1-63][posy1+1]); //Bildschirmausgabe das das Boot gesetzt ist 
        gotoxy(posx1+1-62,posy1+10+1); //springe an die gewählte Position
        printf("%c",feld [posx1-62][posy1+1]); //Bildschirmausgabe das das Boot gesetzt ist 
        }
        else
        {
        gotoxy(35,16);
        printf("Schiff liegt außerhalb des Spielfeldes!!");
        }
        break;
        case 2 : if (feld[posx1-64][posy1+1] == '#'||
        feld [posx1-63][posy1+1] == '#') //Überprüfen ob das Ausgewählte Feld schon belegt ist
        {
        gotoxy(35,16);
        printf("error!! Neues Boot und Feld auswaelen\n");
        }
        else if (posx1>=65 && posx1<=89) //Setzen des Bootes
        {
        feld [posx1-64][posy1+1] = '#';
        feld [posx1-63][posy1+1] = '#';
        gotoxy(posx1+1-64,posy1+10+1); //springe an die gewählte Position
        printf("%c",feld [posx1-64][posy1+1]); //Bildschirmausgabe das das Boot gesetzt ist 
        gotoxy(posx1+1-63,posy1+10+1); //springe an die gewählte Position
        printf("%c",feld [posx1-63][posy1+1]); //Bildschirmausgabe das das Boot gesetzt ist 
        }
        else 
        { 
        gotoxy(35,16);
        printf("Schiff liegt außerhalb des Spielfeldes!!");
        }
        break;
        printf("Moechten Sie weitere Schiffe setzen?"); //Bedingung while-Schleife
        gotoxy(35,14); //springe an diese Position
        printf("ja (j) oder nein(n)?"); 
        scanf("%c",&setzen); 
        fflush(stdin); //Löschen des Eingabe Puffers
        if (setzen != 'n') 
        { 
        löschen(); //Löschen der vorhergehenden Auswahl und Fehlermeldungen
        }
        }
        while (setzen != 'n');
        for (x=1; x<=10; x++) //Ausgabe der Zeichen im Array als Überprüfung
        {
        for (y=1; y<=26; y++) 
        { 
        {
        gotoxy(y+1,x+10);
        printf("%c",feld[y][x]);
        }
        }
        printf("\n");
        }
        return 0;
        }
        


        Die Schussabfrage:
        #include "stdafx.h"
        #include "stdlib.h"
        #include "stdio.h"
        #include "borland.h" // für gotoxy-Befehle
        //eigene Headerdateien
        #include "feld.h" //Feld als globale Variable definieren
        #include "lösche2.h"
        int schussabfrage ()
        {
        int posx=0,posy=0,hilf=0,hilf2=0;
        int x,y;
        int weiter=0;
        float i=0, t=0;
        for (x=1; x<=10; x++) //Ausgabe der Zeichen im Array als Überprüfung
        {
        for (y=1; y<=26; y++) 
        { 
        {
        gotoxy(y+1,x+10);
        printf("%c",feld[x][y]);
        }
        }
        printf("\n");
        }
        do 
        { 
        gotoxy(35,11);
        printf("welcher Buchstabe?"); //Abfrage des Schusses
        scanf("%c",&hilf); 
        fflush(stdin); //Löschen des Eingabe Puffers
        posx = (int) hilf; //Umwandlung in einen int-Wert 
        gotoxy(35,12); 
        printf("Welche Nummer?"); //Abfrage y-wert
        scanf("%i",&posy); 
        fflush(stdin); //Löschen des Eingabe Puffers
        //posy = (int) hilf2; //Umwandlung in einen int-Wert
        if (a_feld[posx-64][posy+1] == 'o' ||a_feld[posx-64][posy+1] == 'x')
        {
        gotoxy (35,15);
        printf("Feld wurde bereits beschossen!");
        }
        if ((posx>=65 && posx<=90)&&(posy>=0 && posy<=9)) //gültiger Schuss
        if (feld[posx-64][posy+1] == '#') //Vergleich mit gesetzten schiffe 
        {
        a_feld[posx-64][posy+1] = 'x'; //Treffer
        t++; //Treffer+1
        i++; //Schüsse +1
        }
        else 
        {
        a_feld[posx-64][posy+1] = 'o'; //kein Treffer
        i++; //Schüsse+1
        }
        else
        {
        gotoxy (35,15);
        printf("ungültiger Schuss");
        }
        gotoxy(posx+1-64,posy+10+1); //an die gewählte Position springen
        printf("%c",a_feld[posx-64][posy+1]); //'x' oder 'o' auf den Bildschirm ausgeben
        gotoxy(35,13); //immer an die gleiche stelle springen, damit feld "unbeschädigt" bleibt
        printf("brechen sie das suchen mit x ab!"); //Bedingung für die while-schleife
        scanf("%c", &weiter); 
        fflush(stdin); //Löschen des Eingabepuffers
        if (weiter != 'x');
        { 
        löschen2(); //Löschen der vorherigen Auswahl
        }
        }
        while (weiter != 'x');
        for (x=1; x<=10; x++) //Ausgabe der Zeichen im Array
        { //Anzeigen der Versteckten Schiffe und der Schüsse
        for (y=1; y<=26; y++) 
        { 
        if (feld[y][x] == '#' && a_feld[y][x] != 'x')
        {
        gotoxy(y+1,x+10);
        printf("%c",feld[y][x]);
        }
        }
        printf("\n");
        }
        gotoxy(35,17);
        printf("Trefferquote:%.2f", (t/i)*100); //Berechnung derr Trefferquote
        return 0;
        }
        



        FAlls du dir das wirklich angeguckt hast, wäre ich dir sehr dankbar!!!!Auch für tipps und Ansätze bin ich jederzeit offen!!
        MfG
        Student90

      • Antwort von nach 11 Stunden 0 hilfreich
        Re^3: array übergeben

        Hallo -

        ich denke Dein Problem liegt an der statischen Felddefinition in der Header-Datei. Ich gehe von der Struktur davon aus das Du verschiedene Quelldateien hast, eine "feld.h" hast und die Dateien dann verlinkst. Dadurch das die Felder 'static' sind, geht das auch gut, sind damit aber auch nur lokal-global (global in jeder Datei aber alles ist ein unterschiedlicher eigener Speicher). Versuche es so:

        1) Nehme die definition von feld und a_feld aus der Header Datei "feld.h" heraus.
        2) Zwischen _tmain() und den Includes schreibe:
        int feld[11][27];
        int a_feld[11][27];
        3) Damit die anderen Teile auch feld und a_feld kennen (und damit das gleiche mit dem gleichen Speicher) kommt direkt nach den includes in den anderen Dateien:
        extern int feld[][];
        extern int a_feld[][];
        (mit dieser Syntax bin ich nicht ganz sicher etwas experimentieren mit den Klammern... das 'extern' zwingt den Compiler/Linker woanders nach der definition von feld und a_feld zu suchen und das ist dann nur in main...)

        Ich hoffe ich konnte Dir damit weiterhelfen, kannst Dich gerne nochmal melden falls Du dazu noch eine Frage hast.

        Als Vorschlag: Ich programmiere recht grosse Anwendungen in C, die relativ schnell sein sollen und aber auch wartbar bleiben sollen. Ich gehe dazu ueber Ansaetze aus der OO Programmierung zu verwenden. Hier haettest Du das feld und a_feld in einer eigenen Datei statisch definiert und der Zugriff geschieht nur ueber Funktionen. Aus Sicherheitsgruenden (integritaet von feld und a_feld) kennen die anderen Programmteile feld nicht (Zum Beispiel hast Du funktionen wie 'setze Schiff', 'Positionsabfrage', 'loesche Schiff'... aber sonst kann keiner auf feld zugreifen).

        Viele Gruesse und viel Spass dabei noch...

        • Antwort von nach 14 Tagen 0 hilfreich
          Re^4: array übergeben

          Hey,

          tut mir leid, dass es etwas gedauert hat, aber ich dachte mir lieber spät als nie...

          in diesen Sinne möchte ich mich bei dir recht herzlich bedanken!!! Mit der extern-Schreibweise hat das ganze genau so funktioniert wie es soll! DANKE für deine Hilfe

          Beste Grüße
          Martin

        • Antwort von nach 19 Stunden 0 hilfreich
          Re: array übergeben

          Hallo,
          ohne Quelltext ist das schwierig zu analysieren.
          Gruß Thomas

      • Antwort von nach einem Tag 0 hilfreich
        Re: array übergeben

        Ich vermute mal, dass das Array zweimal definiert ist, und dass das Eintragen auf die eine Instanz und das Abfragen auf die andere losgeht.

        Eine Header-Datei, die mit #include eingezogen wird ist nichts anderes, als wenn der Text der Datei an der Stelle stünde, wo die include-Anweisung steht. Wenn also in beiden C-Dateien die gleiche Header-Datei includiert wird, hat man das Array zwei Mal. Eigentlich sollte dann der Linker einen Fehler melden.

        Korrekt müsste das Array in einer Datei mit (z.B.)
        int Array [20];
        definiert werden und in der Header-Datei als
        extern int Array [20];
        deklariert werden. Dann sollte es funktionieren.
        Wenn nicht, bitte Quellcode senden.
        Gruß Pit. (Eo steht übrigens für Esperanto)

  3. Antwort von nach 2 Tagen 0 hilfreich
    Re: array übergeben

    Hallo Student90,

    ich bin mir nicht ganz sicher, was das Problem ist, aber ich denke, dass das Array gewissermassen "pro c-Datei" genutzt wird.

    Versuch mal, in der h-Datei das Array als "extern" zu definieren und das Array selbst in einer C-Datei anzulegen:

    spielfeld.h:
    #ifndef __SPIELFELD_H__
    #define __SPIELFELD_H__
    extern char spielfeld[10][10];
    void init_spielfeld();
    #endif // __SPIELFELD_H__

    spielfeld.c:
    #include "spielfeld.h"

    char spielfeld[10][10];
    void init_spielfeld()
    {
    ...
    }

    Ansonsten einfach mal den Quellcode posten.
    PS: Schiffe versenken ist ein prima Versuchskaninchen, um mal mit Pointern zu üben ;-)

    Gruß
    - Mark

  4. Antwort von nach 2 Tagen 0 hilfreich
    Re: array übergeben

    Hallo Student90,

    den großem Monolithen in kleine Module aufzuteilen ist goldrichtig! Immer in kleinen Einheiten denken und arbeiten! Das ist, wie du selbst sagst, übersichtlicher. Die einzelnen Funktionen können aber auch viel einfacher getestet werden.

    Für Schiffeversenken brauchst du natürlich ein Array (auch noch ein zweidimensionales!), und damit musst du dich auch mit Pointers auseinandersetzen. Anders geht es nicht.

    Daten in einer Header-Datei zu definieren ist grundsätzlich ein Fehler. ("Definitonen" mit #define sind keine C-Daten-Definitionen.) In der H-Datei dürfen (globale) Daten nur deklariert werden. Durch die Definition des Array in der H-Datei erhältst du in jeder Datei, in der du die Header-Datei einbindest, ein neues Array! Definition bedeutet Erzeugung! Die Deklaration dagegen teilt dem Compiler nur mit, dass irgendwo das Array einmal definiert, also erzeugt ist. So in etwa:

    schiffeversenken.h:

    #define DIM 15           // Breite und Höhe des Feldes
    extern char[DIM][] feld; // Deklaration des Feldes
    


    main.c:
    #include "schiffeversenken.h"
    char[DIM][DIM] feld;     // Definition des Feldes
    

    Mein Empfehlung zum C-Lernen ist nach wie vor das Buch Programmieren in C von Brian Kernighan und Dennis Ritchie aus dem Hanser Verlag. Kostet gebraucht 11 Euro. Beste Frust-Vermeidung.

    Alles Gute,

    Tosta

  5. Antwort von nach 3 Tagen 0 hilfreich
    Re: array übergeben

    Hallo

    das funktioniert über die Header-Datei nicht. Du musst folgendermassen vorgehen:
    1) Felddeklaration aus der Header-Datei entfernen
    2) Schreibe die Feldeklaration vor (!) die main in die Quellcodedatei des Hauptprogrammes, z.B.
    int feld[100][100];
    int main() { ........
    3) Schreibe in allen anderen Quellcodedateien, in welchen das Feld benötigt wird ganz an den Anfang, d.h. vor (!) die Funktionen, Folgemdes:
    extern int feld[100][100];

    Dann sollte es klappen. Viel Erfolg

    Gruss

  6. Antwort von nach 96 Tagen 0 hilfreich
    Re: array übergeben

    Hallo lieber Student90,

    ist schon etwas her, dass du die Frage stelltest.
    Sorry, ich hatte keine Zeit - und dann ist deine Email etwas
    in Vergessenheit geraten.

    Besteht das Problem mit den Arrays immer noch?
    Wenn ja, dann schick mir doch bitte einmal die
    relevanten Sourcen zu. Die, wo du die Arrays uebergibst.
    Mit Header-Dateien. Und sag mir bitte, bei welcher
    Funktion es nicht geht.

    Ohne Sourcen kann ich auf die Entfernung nicht viel sagen. Da
    ich aber noch Anfänger bin traue ich mich noch nicht so ganz
    an Strukturen und Pointer ran... geht das auch ohne diese
    sachen zu lösen?
    Hmm, der Arrayname alleine ist schon ein Pointer auf
    das erste Element des Arrays. Arrays und Pointer sind also
    sehr miteinander verwandt.

    Sehr schoen erklaert finde ich das Ganze in der C-Bibel:
    Kernighan/Ritchie:
    Programmieren in C

    Hier ist die deutsche Uebersetzung sogar ausnahmsweise
    einmal besser als das Original.

    Viele Gruesse

    Hans

    Jetzt auf diese Frage antworten.