Und zwar möchte ich so etwas wie Schiffe versenken Programmieren bei dem man die Schiffe aber bei jedem Zug bewegen kann.

Jetzt habe ich so angefangen.

JEdes Schiff besteht aus zwei Arrays:

Eins für den Rumpf und eins für den Schussradius.
Der Rumpf wird jeweils im größeren Schussradius zentriert.

Weiterhin hab ich noch ein Spielfeld Array auf das ich jetzt die schiffe setzen will und auf dem sich die Schiffsarrays bewegen sollen.

Jedes Array hat bestimmte Werte:
Schiff : Hitpoints (werden bei jedem Schuss verringert)
Schussradius: Überall 0 ...wird immer abgesucht...wenn schussradius wert != 0 dann Schuss möglich.
Spielfeld: überall 1 für den Unterschied zum schussradius.

Zur erzeugung der Arrays für schiff und Spielfeld hab ich Klassen erstellt.

Jetzt möchte ich in den jeweiligen Klassen folgendes tun:

Ich will die Arraywerte an Pointer übergeben um flexibler damit handhaben zu können.

Allerdings passiert bei folgendem Code das:

#include <iostream>
using namespace std;

class spielfeld
{
    public:

        int sf[10][10];//Spielfeld wird erzeugt

        int nullbelegen(int temp1=0,int temp2=0)//spielfeld wird mit einsen bel.
        {                                       //für spätere Abfrage
            while (temp2 < 10)
            {
                while (temp1 < 10)
                {
                    sf[temp1][temp2] = 1;
                    temp1++;
                }
                temp1=0;
                temp2++;
            }
            int *psf=sf;
        }
};

Hierbei bekomm ich folgende Fehlermeldung:

Cannot convert 'int()[10]' to 'int' in initialization

Bin ich da jetzt ganz falsch oder wo liegt der fehler.
Falls ihr noch andere Vorschläge habt die ich mit meinem beschränkten Wissen verwerten kann...dann nur her damit.

Allerdings wäre ich für eine Erklärung wie das mit den Pointern denn jetzt funzt echt dankbar.

MfG Sunwalker

int array[10][10];

Ist ein Array aus Pointern auf ein Array aus Pointern also letztlich das hier:

int **pointerAufPointer;

Was du machen möchtest geht also so:

int array[10][10];
int **test = array;

int *psf=sf;

gleich richtig

int (*psf)[10] = sf;

int** psf ist bloß eine Hilfskrücke!

Ein 2Dimensionals Array

int array[10][10];

Ist ein Array aus Pointern auf ein Array aus Pointern also letztlich das hier:

int **pointerAufPointer;

Nicht ganz. Man kann zwar über einen int** das Array ansprechen, aber die beiden von dir gezeigten Deklarationen sind grundverschieden. Nur damit es nicht zu Missverständnissen kommt...

Sunwalker schrieb:

JEdes Schiff besteht aus zwei Arrays:

Eins für den Rumpf und eins für den Schussradius.
Der Rumpf wird jeweils im größeren Schussradius zentriert.

Weiterhin hab ich noch ein Spielfeld Array auf das ich jetzt die schiffe setzen will und auf dem sich die Schiffsarrays bewegen sollen.

Scheinen mir etwas viel Arrays zu sein. Hast du da nicht immer doppelte oder sogar dreifache Informationen? Würde eigentlich nicht eine Position (bzw. 2 Vektoren für Anfangs- und Endkoordinaten) reichen?

Also dann könntest du zum Beispiel eine kleine Struktur (oder gleich eine "richtige" Klasse) erstellen:

struct Schiff
{
    int AnfangX, AnfangY;
    int EndeX, EndeY;
    int Schussradius;
    int Trefferpunkte;
};

Oder einfach mehrere Felder auf dem Spielfeld belegen. Ist nur so ein Vorschlag, ich denke nicht, dass sich das so 1:1 umsetzen lässt. Aber über Zusammenfassung ähnlicher Daten zu Strukturen/Klassen solltest du dir vielleicht schon Gedanken machen...

Nicht ganz. Man kann zwar über einen int** das Array ansprechen, aber die beiden von dir gezeigten Deklarationen sind grundverschieden. Nur damit es nicht zu Missverständnissen kommt...

Wie unterscheidet sich die beiden denn intern?
Ich kann aus dem int **test; ja auch ein "Array machen":

int **pointerAufPointer;
for(int i=0; i<10; ++i)
{
    pointerAufPointer+i = new int *[10];
    for(int j=0; j<10; ++j) *(pointerAufPointer+j) = new int [10];
}

Sollte vom Prinzip her ja so gehen, oder?

int (*psf)[10] = sf;

Täusche ich mich oder erzeuge ich damit noch weitere 10 Elemente die ich ja in diesem Fall garnicht haben will?

Arrays
Arrays sind Typen, die mehrere Elemente gleichen Typs hintereinander speichern. Die Grösse muss zur Kompilierzeit feststehen. Das Array unterliegt der automatischen Speicherklasse ( auto ); dessen Speicher wird also beim Verlassen des Gültigkeitsbereichs freigegeben. Wenn man den sizeof -Operator auf ein Array anwendet, erhält man die Anzahl Bytes, die durch die Elemente belegt werden.

Beispiel-Deklarationen:

int Array[4];                   // Array vom Elementtyp int mit 4 Elementen
int Array2[] = {1, 2, 3};       // Initialisierungsliste, Grösse ist 3
int Array3[6] = {1, 2, 3};      // Grösse 6, restliche 3 Elemente werden default-initialisiert

Zeiger
Zeiger hingegen speichern nur eine Adresse. Sie beinhalten selber keine Elemente. Was aber möglich ist, sind "dynamische Arrays" (nicht Arrays im eigentlichen Sinne, sondern die lineare Datenstruktur), die per Zeiger referenziert werden. Ein Zeiger kann auf dynamischen Speicher zeigen, in diesem Falle muss man sich selbst um die Anforderung und Freigabe kümmern. Dass man einen Zeiger auf ein Array zeigen lassen kann, liegt einzig an der Tatsache, dass Arrays implizit zu Zeigern auf das erste Element konvertierbar sind.

Mögliche Anwendungen:

int Var;
int Array[7];
int* Pointer = &Var;        // Zeiger auf ein Objekt im automatischen Speicherbereich
int* Pointer2 = Array;      // Zeiger auf ein Array im automatischen Speicherbereich
int* Pointer3 = &Array[0];  // äquivalent zu Pointer2
int* Pointer4 = new int(4); // Zeiger auf ein dynamisch angelegtes Objekt
int* Pointer5 = new int[7]; // Zeiger auf ein dynamisches "Array" mit 7 Elementen

delete Pointer4;
delete[] Pointer5;

Ich kann aus dem int **test; ja auch ein "Array machen":
Sollte vom Prinzip her ja so gehen, oder?

Sind die Arraydimesionen beim Compilieren bekannt erzeugt man das Array so:

int sf[10][10];
// oder dynamisch
    int (*sf)[10]  = new int[10][10];

Das ist eine Krücke!
@blub²:

int **pointerAufPointer;
for(int i=0; i<10; ++i)
{
    pointerAufPointer+i = new int *[10];
    for(int j=0; j<10; ++j) *(pointerAufPointer+j) = new int [10];
}

Ja stimmt ich habe da ein paar Informationen zu viel...allerdings sah ich bis jetzt keine andere Möglichkeit ...könntest du mir deine Variante eventuell nochmal genauer erklären also das mit den Start und End-werten...
Wichtig bei diesen Projekt ist mir ja dass ich die einfacheren C++ Funktionen kennen lerne und ein wenig Intuition dafür bekomme.

@alle

Vielen Dank auf jedenfall mal ...zumindest ist mir jetzt mehr bewusst wie so ein Pointer fungiert.
Ich werde mal ein paar der Tipps ausprobieren um zu sehen wie sich das auf den Rest meins Programms auswirkt.

Für weitere Tipps bin ich natürlich dankbar

OOOXOOO
OOOXOOO
OOOXOOO
OOOOOOO

Und da wäre es doch einfacher, die beiden Enden des Schiffs als Koordinaten zu speichern. Also hier (1|4) und (3|4) - wenn x nach rechts und y nach unten zeigt. Die Schussweite und Trefferpunkte kannst du ja so trotzdem haben.

#include <iostream>
using namespace std;
class schiff
{
    public:

        int rumpf[3];// Ausdehnung des Schiffes
        int radius[7][7];//Schussfeld erster Eintrag Zeile, zweiter Eintrag 
                         //Spalte
        int *pr;
        int *pra;

        void hpbelegen()//hitpoints werden vergeben
        {
            rumpf[0]=1;
            rumpf[1]=2;
            rumpf[2]=1;
            int *pr=&rumpf[0];
        }
        void sradius(int temp1=0,int temp2=0)//Schussradius wird mit null belegt
        {
            while (temp2 < 7)
            {
                while (temp1 < 7)
                {
                    radius[temp1][temp2] = 0;
                    temp1++;
                }
                temp1=0;
                temp2++;
            }
            radius[4][3]=rumpf[0]; //Schiff wird ins Zentrum des Schussradius 
                                   //gesetzt
            radius[4][3]=rumpf[1];
            radius[4][5]=rumpf[2];
            int *pra=&radius[0][0];
        }

};

Das wird jetzt gemacht ohen Fehlermeldung...

Jetzt wollte ich testen ob ich den Pointer in meiner Main Funktion ausgeben kann:

#include <iostream>
#include <math.h>
#include "Schiff.cpp"
#include "Spielfeld.cpp"
using namespace std;
int main(int *pr)
{
    spielfeld sf;//Spielfeld wird erzeugt
    sf.nullbelegen();//Spielfeld wird belegt
    schiff kreuzer1;//Schiff Spieler1
    kreuzer1.hpbelegen();//SchiffsHP werden belegt
    kreuzer1.sradius();//Schussradius wird generiert
    cout<<*kreuzer1.pr;//ichhab auch schon & anstatt * probiert und statt pr
                       //auch pr[0]
                       //...das programm geht natürlich noch weiter ist aber 
                       //irrelevant für den Fehler

Allerdings gibt mir das Programm jetzt anstatt "1"---> 0X44a7b8 aus wenn ich es ohne "" eingebe und 4479568 mit "" und 0x22fd90 mit "&"...so was ist jetzt die richtige Syntax damit da eine EINS steht...

Vieldn Dank MfG Sunwalker

da liegt der Fehler

int

int *pr=&rumpf

--->

int *pr=rumpf[0]

der fehler besteht aber weiterhin .
jönntest du eventuell näher erläutern was du meinst wäre echt super

Danke Mfg Sunwalker

*pr = &rumpf;

statt

int *pr = &rumpf;

MfG Sunwalker