Map Map1;

und dann möchte ich davon ein array erstellen. in der "showMap();" funktion sagte ich :

void InOutput::ShowMap(int mapwidth, int mapheight, Map mapnum(da is die Map1), Player playernum)
{
	for (int y = 0; y < mapwidth; y++)
	{
		for (int x = 0; x < mapheight; x++)
		{
			if (mapnum[y][x].inBenuzung == true)
			{
                              cout << "X";
                        }
                        else
                        {
                              cout << ".";
                        }
		}
	}
};

er sagt mir aber dass ich den "[]" operator nicht verwenden kann.
wie kann ich dass lösen?

würde es gehen wenn ich dir das project sende?

Ne, wir posten immmer hier im Forum. Wir posten immer nur Minimalbeispiele, das die Fehler/das Problem reproduziert. So hast du am meisten Chancen, dein Problem zu lösen.

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?

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

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.
	{
		// ...
	}
}

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

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)

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

#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!

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

:p Andersum. Erst Typ, dann Size.

@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 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 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).

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.

#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