class array global definieren

WhileTrueDo

sry natürlich 2D

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

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

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!

@Sone: Warum ist das proxy-Objekt privat?

SeppJ

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

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

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.

SeppJ

Ja, die Analogie ist mir schon klar :p . Ich find's andersrum aber übersichtlicher, denn oft verschachtelt man die Arrays:

array<superlange typangabe<mit vielen<verschachtelten>, templates>, wie viele>

Da muss man beim Lesen viel hin und her springen, ebenso beim Schreiben. Andersrum hingegen hat man all die schnell erfassbaren Informationen auf einen Blick, danach kann man sich die dicke Typangabe ansehen. Daher mache ich es intuitiv oft falsch herum. Aber die Reihenfolge, wie sie ist, ist in der Sprache schon so tief verwurzelt, es wäre inkonsistent das in diesem Fall anders zu machen.

camper

Man kann die Umwandlung auch dem Compiler überlassen

#include <array>
#include <cstddef>

template <typename T>
struct identity
{
    using type = T;
};

template <typename T>
using eval = typename T::type;

template <typename T>
struct make_std_array
    : identity<T> {};

template <typename T, std::size_t N>
struct make_std_array<T[N]>
    : identity<std::array<eval<make_std_array<T>>,N>> {};

template <typename T>
using std_array = eval<make_std_array<T>>;

#include <type_traits>
static_assert( std::is_same<std_array<int[3][4]>, std::array<std::array<int, 4>, 3>>::value, "" );

ideone