class array global definieren

[WhileTrueDo]

also was ich machen möchte ist, ich will ein 3D array erstellen. dass soll meine Map bilden.

[out]

WhileTrueDo schrieb:

also was ich machen möchte ist, ich will ein 3D array erstellen. dass soll meine Map bilden.

3D, also x,y,z? Also map[x][y][z]? Vom Typ bool?

[WhileTrueDo]

sry natürlich 2D

[out]

Wie groß ist x und y? Immer gleich groß? Oder dynamisch? Zeig mal die Klasse Map

[WhileTrueDo]

class Map
{
public  :
	Map();
    void createBlock(Map mapnum);
	void deleteBlock(Map mapnum, Player playernumber);
	void clearMap(Map mapnum,int mapwidth , int mapheight);

	bool InUse;
	int  ID;
	int  MapWidth;
	int  MapHeight;
};

Map::Map()
{
	MapWidth  = 79;
	MapHeight = 23;
};

[SeppJ]

Und wo ist da die 2D-Struktur? Oder überhaupt irgendwelche Nutzdaten?

Wieso nimmst du nicht die fertigen Datenstrukturen der Standardbibliothek? Klingt so, als suchtest du vector, array, map oder eine Kombination davon.

[WhileTrueDo]

ich will einfach nur ein 2D array auf dass ich überall durch instanzen zugreifen kann

[out]

Also du willst sowas, wenn ich es richtig verstanden habe?

class Map
{
private:
	bool data[79*23];
public:
	const bool& operator()(unsigned x, unsigned y) const {return data[x*23 + y];}
	      bool& operator()(unsigned x, unsigned y)       {return data[x*23 + y];}
};

int main()
{
	Map mapnum;

	if ( mapnum(3,4) ) // Entspricht: if ( mapnum[3]4] ) und das == true kannst du dir sparen.
	{
		// ...
	}
}

[WhileTrueDo]

in der main schreibe ich :

Map Map1;

int main()
{
showmap(Map1);
getinput(input1*/nicht so wichtig/*);
runfunktion(Map1);
}

und in der map.hpp :

void showmap(Map mapnum);

und dann in der map.cpp

void showmap(Map mapnum)
{
mapnum[x][y].mach dass und dass
};

aber ich weiss nicht wie ich das mit dem array regeln soll da diese variante nicht funktioniert

[out]

Tut mir , aber ich blicks nicht. SeppJ übernimmt das jetzt :D, und ich geh schlafen.

[Skym0sh0]

Wenn du eine eigene Klasse schreibst kannst du ohne Probleme den operator[] überladen. Aber einen operator[][], wie du ihn haben möchtest, gibt es nicht. (Vllt kann da einer von den Gurus irgendwie tricksen, aber das hilft dir nicht weiter, da du beim kleinsten Fehler wahrscheinlich schon nicht wüsstest, was wie wo nicht geht oder kaputt ist.)

Zumal du auch eh eher einen C-lastigen Ansatz hast.
Mach es wie out vorgeschlagen hat und überlade den operator(), dann schreibst du halt statt: map[x][y] nur map(x, y)

[Braunstein]

Hallo,

2D Indexoperatoren kann man über eine Proxyklasse realisieren. Man gibt dann einfach im Indexoperator diese Proxyklasse zurück die wiederum selbst einen überladenen Indexoperatur hat.
Erklärung z. Bsp. hier
http://www.c-plusplus.net/forum/232303-full

[Sone]

Schon mal was von einem Proxy-Objekt gehört?

#include <cstddef>

class Map
{
private:
    bool data[79*23];

    template<typename ValT>
    class proxy
    {
    	ValT* arr;

    	friend class Map;

    	proxy( ValT* arr ):
			arr{arr} {}

	public:

		ValT& operator[]( std::size_t i ) { return arr[i]; }
    };

public:

	Map() : data{} {}

    proxy<const bool> operator[]( std::size_t x ) const { return proxy<const bool>{ data + x*23 }; }
    proxy<bool>       operator[]( std::size_t x )       { return proxy<      bool>{ data + x*23 }; }
};

int main()
{
    Map m;

    m[4][2] = true;
}

Edit: Verflucht seist du, Braunschwein!

[sternbein]

@Sone: Warum ist das proxy-Objekt privat?

[SeppJ]

typedef std::array<23, std::array<79, bool>> map;

[out]

SeppJ schrieb:

typedef std::array<23, std::array<79, bool>> map;

:p Andersum. Erst Typ, dann Size.

[Sone]

sternbein schrieb:

@Sone: Warum ist das proxy-Objekt privat?

Mir ist klar, dass man auch so auf den Typ zugreifen kann. Einfach so, nehme ich an.

[SeppJ]

out schrieb:

SeppJ schrieb:

typedef std::array<23, std::array<79, bool>> map;

:p Andersum. Erst Typ, dann Size.

Ach, ich kann das nie auswendig behalten. Statisch dimensionierte Arrays benutze ich ehrlich gesagt nur sehr selten

[out]

SeppJ schrieb:

out schrieb:

SeppJ schrieb:

typedef std::array<23, std::array<79, bool>> map;

:p Andersum. Erst Typ, dann Size.

Ach, ich kann das nie auswendig behalten. Statisch dimensionierte Arrays benutze ich ehrlich gesagt nur sehr selten

Ich finds logisch. Man fragt doch immer zuerst nach dem was , und dann nach dem wie (viele).

[Sone]

Ich habe es vorher auch verwechselt, aber man muss sich vorstellen, dass es einfach wie bei der Deklaration eines echten Arrays aussieht: Erst die Typangabe, dann die Bounds.