Hier mein Programm:

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
//#include <time.h>

using namespace std;

const int X=8;
const int Y=8;

int main()
{
  srand(time(NULL));

  int x,y;
  int z;
  char bamx;
  int xkonv;
  int bamy;
  int ende;
  char feld[X][Y];

  int schiffx=(rand()%6+1); //Zufallsschiff definieren im Feld
  int schiffy=(rand()%8+1); //Zufallsschiff definieren im Feld

  for(y=1;y<Y+1;y++)
  {
        for(x=1;x<X+1;x++)
         {
            feld[x][y]='.';
         }
  }

  for (z=0;z<3;z++)
  {
      feld[schiffx+z][schiffy]='o'; //Schiffsfelder mit 'o' füllen  }

  do
  {
  cout<<"\n A B C D E F G H\n";

  for(y=1;y<Y+1;y++)
  {
        cout<<y;
        for(x=1;x<X+1;x++)
          {
            cout<<feld[x][y]<<" ";
          }
        cout<<"\n";
  }

  cout<<"\nZielkoordinaten eingeben: ";
  cin>>bamx>>bamy;
  switch(bamx) 
  {
   case 'A' : xkonv=1; break;
   case 'B' : xkonv=2; break;
   case 'C' : xkonv=3; break;
   case 'D' : xkonv=4; break;
   case 'E' : xkonv=5; break;
   case 'F' : xkonv=6; break;
   case 'G' : xkonv=7; break;
   case 'H' : xkonv=8; break;           
  }

  if (bamy==schiffy)
  {
    if  (xkonv==schiffx || xkonv==schiffx+1 || xkonv==schiffx+2)
    {
        cout<<"\nTREFFER\n";
    }                
  }
  else {cout<<"\nDANEBEN\n";}

  if (xkonv>0 && xkonv<9 && bamy>0 && bamy<9)
  {
     feld[xkonv][bamy]='x';
  }

  else
  {
     ende=0;
  }

  }
  while(ende!=0);

  getchar();  

}

Ich weiß nun nicht warum immer wenn ich den Teil mit dem "Zufallsschiff" einbaue immer am Ende des Feldes ein Spade - Zeichen (Wie heißt das bloß in Deutsch beim Kartenspielen.... Treff... Naja egal) kommt.

Der nächste Schritt wäre dann die Anzeige wegzulassen sodass ich selbst natürlich die Schiffe nicht sehen kann und womöglich mehrere einzubauen.
Außerdem Schiffe die nicht nur in X - Richtung erweitert werden.
Aber da fehlt mir noch die Fantasie bzw. fehlen mir noch die Möglichkeiten.

Ich hoffe ich konnte es gut beschreiben und erhalten viele nette Hallo´s und hilfreiche Antworten und ein paar patzige "haha anfänger". (Sonst wäre ja kein Spaß dabei etwas in ein Forum zu schreiben )

char feld[X][Y];

definierst du ein Array, das von feld[0][0] bis feld[X - 1][Y - 1] gültig ist. Mit

for(y=1;y<Y+1;y++)
  {
        cout<<y;
        for(x=1;x<X+1;x++)
          {
            cout<<feld[x][y]<<" ";
          }
        cout<<"\n";
  }

läufst du von feld[1][1] bis feld[X][Y] - ersteres ist zwar Speicherverschwendung, aber nicht wirklich problematisch, zweiteres dagegen bedeutet, dass du Speicher ausliest, der nicht mehr zum Array gehört. Das löst undefiniertes Verhalten aus, d.h. alles mögliche kann passieren - in diesem Fall wird vermutlich der Wert einer der anderen Variablen als char interpretiert und ausgegeben.

1. stdlib.h und stdio.h sind C Header, in C++ bindet man stattdessen cstdlib und cstdio ein
2. Gut, dass du Konstanten mit static const definierst und kein #define dafür benutzt, wie man das in C oft sieht
3. Variablen werden in C++ möglichst erst dann deklariert, wenn man sie tatsächlich benötigt. Zum guten Stil gehört auch, sie möglichst lokal zu benutzen und bei der Deklaration auch zu initialisieren.
4. In C/C++ beginnt ein Array mit dem Index 0, nicht mit 1.
5. Den ganzen switch-case Block kann man sich sparen, wenn man von bamx und bamy 'A' (oder 'a', je nach Groß-/Kleinschreibung) abzieht (siehe ASCII Tabelle und numerische Werte von Buchstaben)
6. Ist Geschmackssache, aber die Art einzurücken gefällt mir nicht, insbesondere Zeile 74. Man sollte immer einheitlich einrücken (siehe Zeile 74 und 81-84).

Doch seit einiger Zeit habe ich große Interesse und habe auch schon die Grundlagen von C "studiert" um die Basis für C++ zu erlangen.

C-Vorkenntnisse können schaden.

Ein paar Anmerkungen:
1. Die "C-Kompatibilitätsheader" werden im C++ Standard mit einem vorgestellten c, und ohne Dateiendung verwendet (z.B. <cstdlib> statt <stdlib.h>). Sie liegen wie die C++ Header im Namensraum std. conio sollte man eigentlich nicht mehr verwenden, und ist auch kein Bestandteil des C++ Standards.
2. Variablen sollte man so lokal wie möglich deklarieren, und möglichst auch direkt initialisieren. Am Besten bei der ersten Verwendung.
3. Bezeichner sollte man so wählen, das die Bedeutung sich beim lesen direkt erschließt. Man liest Code wesentlich häufiger als man ihn schreibt. xkonv, bamx und ähnliches ist jedenfalls nicht lesbar.
4. Zählvariablen von for-Schleigen würde ich auch erst in dieser deklarieren, wenn man nicht das Endergebnis der Schleife anderweitig benötigt. Wiederverwendung von Variablen gilt eigentlich als schlechter Stil (Und da eine im for deklarierte Variable nur lokal gilt, kann man den gleichen Bezeichner auch später nochmal für eine lokale Variable nutzen).

MichaelMAS schrieb:

Ich habe ein C++ Buch welches jedoch stark auf die objektorientierte Programmierung für Fortgeschrittene eingeht.

Darf ich erst einmal fragen welches?

MichaelMAS schrieb:

Daher orientiere ich mich eher an Online-Bücher / Tutorials.

Ich kenne kaum ein gutes Tutorial für C++.

Leider fehlt mir für eine genauere Analyse deines Programms aber die Zeit.

Bei der Deklaration kannst du die Variablen vom gleichen Typ in einer Zeile deklarieren (hast ja bei int schon teilweise gemacht). Die geschweiften Klammern bei einzeiligen Befehlen (z.B. nach if und else) kannst du auch weglassen (wenn sie weggelassen werden, wird nur die nächste Zeile interpretiert.

1. Die "C-Kompatibilitätsheader" werden im C++ Standard mit einem vorgestellten c, und ohne Dateiendung verwendet (z.B. <cstdlib> statt <stdlib.h>). Sie liegen wie die C++ Header im Namensraum std.

Wieso funktioniert das hier eigentlich:

#include <cstdio>

int main()
{
    printf("Hallo\n");
}

wenn printf im Namensraum std liegt? (VSE2009)

Wieso funktioniert das hier eigentlich:
...
wenn printf im Namensraum std liegt? (VSE2009)

VSE2009 kenne ich zwar nicht (wenn 2008 oder 2010), aber wenn mein Englisch nicht sehr schlecht ist, würde ich aus dem Draft es so lesen, das der VSE hier nicht ganz richtig ist.

[Auszug aus 17.4.1.2 §4, ]
"...In the C++ Standard Library, however, the declarations and definitions except for names which are defined as macros in C) are within namespace scope (3.3.5) of the namespace std."

1. Das ist durch die Optimierungen kürzer und übersichtlicher geworden.
   (Stichwörter Switch/Else, Deklarierungen in einer Zeile, Geschwungene Klammern, Codestruktur,etc..)
2. Das Programm funktioniert!
   (Stichwort Zugriff auf Teil des Arrays der nicht mehr dazugehört)
3. Die Bibliotheken habe ich ohne Header .h und mit c davor und conio lasse ich weg!

Das Buch werde ich sobald ich kann hier mit Titel und Autor angeben.
Ich habe es zwar beiseite gelegt aber keineswegs verworfen!

Bezüglich Tutorials verwende ich 2 die hier unter Neulingshilfe und Links angegeben sind und Wikibooks C++.

Das mit dem Switch/Else weglassen und stattdessen A abziehen hat nach kurzer Recherche wie das genau gemeint war funktioniert, aber genau verstehe ich nicht wie ich von einer int Zahl einfach 'A' abziehen kann.

cout<<"\nZielkoordinaten eingeben: ";
  cin>>bamx>>bamy;
  konvx=bamx - 'A';
  konvy=bamy - '1';

Aber es funktioniert!

Eine Frage noch:
Die geschwungenen Klammern bei einzeiligen zb. if else Bedingungen weglassen verstehe ich, aber ích sehe keine Möglichkeit das in meinem Code zu nutzen, da alles eigentlich immer länger als eine Zeile ist!
Oder meintest du damit, dass ich es öfters ruhig auf eine Zeile verkürzen sollte bei einfachen Anwendungen???

lg und danke an alle auch wenn ich nicht alle beim Namen nenne!

Michael

MichaelMAS schrieb:

Grundlagen von C "studiert" um die Basis für C++ zu erlangen.

Wenn man C++ erlernen will erstmal C zu machen... davon wird i.A. abgeraten,da C und C++ doch etwas andere Paradigmen verfolgen. Sieht man z.B. an ein paar Dingen in deinem Quellcode.

MichaelMAS schrieb:

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

In C++ gibt es eine "Neuauflage" gewisser Headern, und diese enden nicht mehr auf '.h' sondern bekommen ein 'c' vornehin, wie z.B. 'cstdio'

MichaelMAS schrieb:

const int X=8;
const int Y=8;

Die Philosophie von C++ ist, Variablen/Objekte so lokal wie möglich zu halten und so spät wie möglich zu definieren (am besten eine Initialisierung, falls möglich)

MichaelMAS schrieb:

char feld[X][Y];

Wenn es geht, vermeidet man in C++ 'normale', 'rohe' Arrays und benutzt stattdessen sog. Conatiner. Wenn man nicht weiß, welcher nun der Geeignete ist, nimmt man immer std::vector.

MichaelMAS schrieb:

int x,y;
char feld[X][Y];

Normal müsste dies einen Fehler verursachen, da man für nicht-dynamische Arrays als Größenangabe eine Compiletime-Konstante benutzen muss (also eine Zahl, die zur Kompilation bekannt ist und konstant ist):

char ar[7];

// oder
const int size = 7;
char ar_2[size];

PS: Ich finde es gut, dass du versuchst einzurücken, aber versuche die "Einrückgröße" konstant zu halten, das macht es dann noch etwas leserlicher

lg

if (bamy==schiffy)
  {
    if  (xkonv==schiffx || xkonv==schiffx+1 || xkonv==schiffx+2)
        cout<<"\nTREFFER\n";         //Klammer weg
  }
  else {cout<<"\nDANEBEN\n";}

  if (xkonv>0 && xkonv<9 && bamy>0 && bamy<9)
     feld[xkonv][bamy]='x';         //Klammer weg

  else
     ende=0;         //Klammer weg

Mit for-Schleifen kann man das auch machen (solange die zu dieser Schleife gehörende Prozedur eine Zeile umfasst).

Grüße,
Rewind.

Dann habe ich soweit einiges eingebaut schon, aber eine Frage ergibt sich.
Ich weiß zwar wie ich den Fehler ausbessere aber wieso ich ihn ausbessern muss damit alles funktioniert weiß ich nicht. Also: Was ist daran falsch?

do
  {
  cout<<"\n A B C D E F G H\n";

  for(y=0;y<Y;y++)
  {
        cout<<y+1;
        for(x=0;x<X;x++)
          {
            cout<<feld[x][y]<<" ";
          }
        cout<<"\n";
  }

  cout<<"\nZielkoordinaten eingeben: ";
  cin>>bamx>>bamy;
  konvx=bamx - 'A';
  konvy=bamy - '1';

  if (konvx>0 && konvx<9 && konvy>0 && konvy<9) //Hier liegt der Hund begraben!
  {
     feld[konvx][konvy]='-';
     if (konvy==schiffy)
     {
        if  (konvx==schiffx || konvx==schiffx+1 || konvx==schiffx+2)
        {
           feld[konvx][konvy]='x';
           cout<<"\nTREFFER\n";
        }                
     }
     else {cout<<"\nDANEBEN\n";}
  }
  else
  {
     ende=0;
  }

  }
  while(ende!=0);

Wenn ich dann:

if (konvx>0 && konvx<9 && konvy>0 && konvy<9)

funktioniert es wieder auch wenn ich zb. A1 eingebe!

Why????

Also das feld auch erst definieren, wenn man es wirklich braucht!
Werd ich machen und mir merken!

Gugelmoser eine Frage zum letzten Ding:

Normal müsste dies einen Fehler verursachen, da man für nicht-dynamische Arrays als Größenangabe eine Compiletime-Konstante benutzen muss (also eine Zahl, die zur Kompilation bekannt ist und konstant ist):
...

Wieso?

Ich habe doch:

const int X=8;
const int Y=8;
...
char feld[X][Y];

DANKE WIEDER MAL AN ALLE UND BIS GLEICH :D

if (konvx>0 && konvx<9 && konvy>0 && konvy<9)

gehts natürlich nicht, wäre ja das gleich!

Bei:

if (konvx>=0 && konvx<9 && konvy>=0 && konvy<9)

gehts dann!
Wieso?

Bei:

if (konvx>=0 && konvx<9 && konvy>=0 && konvy<9)

gehts dann!
Wieso?

Weil 0 in diesem Fall auch mögliche Werte für konvx und konvy ist. 'A' ist als 65 kodiert und wenn man 'A' (65) eingibt und danach von der Eingabe 'A' (65) abgezogen wird, kommt eine 0 raus.

Gugelmoser schrieb:

Normal müsste dies einen Fehler verursachen, da man für nicht-dynamische Arrays als Größenangabe eine Compiletime-Konstante benutzen muss (also eine Zahl, die zur Kompilation bekannt ist und konstant ist):

Das stimmt nicht, weil sie bekannt sind. Gugelmoser hat sich vermutlich verguckt. Du könntest dir noch andere Variablennamen für die for-Schleifen, in den du x und y (klein) verwendest, überlegen (z.B. i und j) damit es nicht zu Verwechslungen kommt. Oder deine globalen Konstanten anders nennen (XMAX bzw. YMAX oder so)...

Gugelmoser eine Frage zum letzten Ding:

Normal müsste dies einen Fehler verursachen, da man für nicht-dynamische Arrays als Größenangabe eine Compiletime-Konstante benutzen muss (also eine Zahl, die zur Kompilation bekannt ist und konstant ist):

Stimmt, haste recht, da habe ich wohl ein kleines x statt ein großes gelesen. Da siehst du auch gerade, dass man Namen wohl besser nicht klein und groß geschrieben verwenden sollte, da man schnell mal durcheinander kommt.

Belli schrieb:

Wieso funktioniert das hier eigentlich:
...
wenn printf im Namensraum std liegt? (VSE2009)

VSE2009 kenne ich zwar nicht (wenn 2008 oder 2010), aber wenn mein Englisch nicht sehr schlecht ist, würde ich aus dem Draft es so lesen, das der VSE hier nicht ganz richtig ist.

Du hast natürlich recht: VSE2008 (Visual C++ 9.0) ... aber ...
mein g++ (3.4.5) übersetzt es auch ohne Murren ...

if (xkonv>0 && xkonv<9 && bamy>0 && bamy<9)
     feld[xkonv][bamy]='x'; // feld[8][8] könnte entstehen... Speicherzugriffsverletzung

Das mit dem A(ASCII 65) ist mir auch klar. Denn wenn 0 rauskommt und bei 0 bricht die Schleife ab --> Klar das es nicht funktioniert!

DANKE DERWEIL!

Dieses Programm ist derweil mal soweit erledigt und meine Fragen geklärt!

Ihr seid alle miteinander toll und ich hoffe nächstes mal kann ich ein bereits "optimierteres" Programm an euch übergeben um etwaige Fragen zu stellen!

lg

Michael

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <time.h>

using namespace std;

const int X=8;
const int Y=8;

int main()
{
  srand(time(NULL));

  int x,y,z,konvx,konvy,ende;
  char bamx,bamy,feld[X][Y];
  int schiffx=(rand()%6);
  int schiffy=(rand()%8);

  for(y=0;y<Y;y++)
  {
        for(x=0;x<X;x++)
            feld[x][y]='.';
  }

  for (z=0;z<3;z++)
       feld[schiffx+z][schiffy]='o';

  do
  {
     cout<<"\n A B C D E F G H\n";
     for(y=0;y<Y;y++)
     {
        cout<<y+1;
        for(x=0;x<X;x++)
            cout<<feld[x][y]<<" ";
        cout<<"\n";
  }

  cout<<"\nZielkoordinaten eingeben: ";
  cin>>bamx>>bamy;
  konvx=bamx - 'A';
  konvy=bamy - '1';

  if (konvx>=0 && konvx<9 && konvy>=0 && konvy<9)
  {
     feld[konvx][konvy]='-';
     if (konvy==schiffy)
     {
        if  (konvx==schiffx || konvx==schiffx+1 || konvx==schiffx+2)
             feld[konvx][konvy]='x'; cout<<"\nTREFFER\n";
     }
     else {cout<<"\nDANEBEN\n";}
  }
  else
  {
     ende=0;
  }
  }
  while(ende!=0);
  getchar();
}

Du hast natürlich recht: VSE2008 (Visual C++ 9.0) ... aber ...
mein g++ (3.4.5) übersetzt es auch ohne Murren ...

GCC G++ 4.3.4 murrt.
CodeGear 2009 murrt.

if  (konvx==schiffx || konvx==schiffx+1 || konvx==schiffx+2)
             feld[konvx][konvy]='x'; cout<<"\nTREFFER\n";

dann wird nur feld[konvx][konvy]='x'; ausgeführt, wenn eine der if-Bedingungen zutreffen. In diesem Fall gibt es zwei Anweinsungen (Wertzuweisung und cout), die in geschweifte Klammer gepackt werde sollten.

Eins solltest du noch wissen: C++-Standard schreibt vor, dass die int main() -Funktion einen Rückgabewert zurückgeben muss. Wenn sie nicht 0 zurückgibt, wird die Ausführung vom System als fehlerhaft interpretiert.

Nochmal zu

if (konvx>=0 && konvx<9 && konvy>=0 && konvy<9)

Da dein Array 8 Elemente hat, geht der Index von 0 bis 7. Für deine if-Überprüfung heißt es:

if (konvx>=0 && konvx<8 && konvy>=0 && konvy<8)

Aber das mit dem nur die erste Anweisung wird ausgeführt bzw. umgesetzt verstehe ich zwar, aber bei mir funktioniert es trotzdem.

if  (konvx==schiffx || konvx==schiffx+1 || konvx==schiffx+2)
             feld[konvx][konvy]='x'; cout<<"\nTREFFER\n";

Aber Treffer wird immer angezeigt!

Was stimmt jetzt? Oder liegt das daran, dass ich DEV C++ verwende?

Aber Treffer wird immer angezeigt!

Genau. Das liegt aber nicht am Compiler, sondern daran, dass nur die erste Anweisung durchgeführt wird, wenn if(...) zutrifft. Das bedeutet, dass "cout" unabhängig von if ausgeführt wird. Dazu müsstest du die Klammern setzen (weil es zwei Befehle sind, jeder endet ja mit Semikolon ";"):

if  (konvx==schiffx || konvx==schiffx+1 || konvx==schiffx+2)
        {
             feld[konvx][konvy]='x'; 
             cout<<"\nTREFFER\n"; 
        }

Jetzt versteh ichs!

Hab übersehen das immer TREFFER kommt auch wenn ich nicht treffe!

DANKE

#include <iostream> 
#include <cstdlib> 
#include <cstdio> 
#include <ctime>  // statt time.h

using namespace std; 

const int X=8; 
const int Y=8; 

int main() 
{ 
  srand(time(NULL)); 

  char feld[X][Y]; 
  int schiffx=(rand()%6); 
  int schiffy=(rand()%8); 

  for( unsigned int y = 0; y < Y; y++) // lokale Zählvariable y
  {
      for( unsigned int x = 0; x < X; x++) // lokale Zählvariable x
      {
         feld[x][y]='.'; 
      }
  }
  for( unsigned int z = 0; z < 3; z++) // lokale Zählvariable z
  {
     feld[schiffx+z][schiffy]='o';  
  }

  bool Ende = false;
  do 
  { 
     cout<<"\n A B C D E F G H\n"; 
     for( unsigned int y = 0; y < Y; y++) // lokale Zählvariable y
     { 
        cout<<y+1; 
        for( unsigned int x = 0; x < X; x++) // lokale Zählvariable x
        {
            cout<<feld[x][y]<<" "; 
        }
        cout<<"\n"; 
     } 

     cout<<"\nZielkoordinaten eingeben: "; 
     int bamx = 0; // bamx, bamy werden erst hier benötigt, also auch erst hier definieren
     int bamy = 0; 
     cin>>bamx>>bamy; 
     int konvx=bamx - 'A'; // siehe bamx, bamy
     int konvy=bamy - '1'; 

     if( konvx >= 0 && konvx < 9 && konvy >= 0 && konvy < 9 ) 
     { 
        feld[konvx][konvy]='-'; 
        if( konvy==schiffy ) 
        {
           if( konvx==schiffx || konvx==schiffx+1 || konvx==schiffx+2 ) 
           {
              feld[konvx][konvy]='x'; cout<<"\nTREFFER\n"; 
           }
           else 
           {
              cout<<"\nDANEBEN\n";
           }
        }
     } 
     else 
     { 
        Ende = true; 
     } 
  } 
  while( !Ende ); 
  getchar(); 
}

Bin wohl bei den ganzen Vorschlägen bei dem hier auf der Leitung gestanden.
Das erleichtert die Auswahl an Zählern ungemein und man kommt nicht so leicht durcheinander! Diese unsigned int variablen sind also nur zum zählen und können daher zuvor undefiniert aufgerufen werden!
Toll!
Und dann kann ich doch zb. für alle for-Schleifen unsigned i verwenden, oder?
Ich definiere ja immer nur für eine Schleife und nicht global davor!

THX