Tablica jako składowa klasy

Witam, piszę grę coś w stylu space invaders, tzn lecimy sobie samolocikiem nazwijmy to z lewej do prawej. Z prawej strony nadlatują przeciwnicy których musimy zniszczyć. I tak, wymyśliłem sobie, że zrobię sobie klasę pole, oraz klasę tablica pól. W klasie pole mamy takie składowe jak typ pola (np 4 to ściana, 3 to puste pole, a 2 to załóżmy przeciwnik), pole ponad nami, pole na lewo, na prawo i pole pod nami.
W klasie tablica pól tworzę 2 tablice.
Pierwsza to tablica przechowująca właśnie typ pól tzn int type[11][14] = { {4,4,4,4.....}, {4,3,3,3.....}, ....}}; coś w tym stylu, a druga tablica to tablica wskaźników na obiekty typu pole tzn Area *areas[11][14];

Problem polega na tym, że kiedy w pliku board_cpp chcę w konstruktorze zainicjalizować moją tablicę type to sypią mi się błędy w postaci, że brakuje nawisu klamrowego lewego, prawego, przecinka i tak w kółko. Składnie jest na pewno dobrze.

Moje pytanie brzmi, czy można tak z tablicami ogólnie robić bo przeczytałem gdzieś w necie, że tablica nie może być składową klasy bo jest właśnie problem z jej inicjalizacją. Pod spodem zamieszczam kody

#ifndef board_h
#define board_h

#include "area.h"

/**
* Klasa reprezentuje pole gry
*/

class Board
{
private:
	Area *areas[11][14];
	int type[11][14];
public:
	//konstruktor
	Board();

	//metoda do rysowania planszy
	void print();

	//metoda do odnajdywania miejsca startu pionka
	Area getStartArea();

	//metoda do sprawdzenia czy wszystkie potwory sa zniszczone 
	bool allAreasClean();
};

#endif board_h

#ifndef board_cpp
#define board_cpp

#include <iostream>
#include "area.h"
#include "board.h"

using namespace std;

Board::Board()
{
	type[11][14] = { {4,4,4,4,4,4,4,4,4,4,4,4,4,4}, 
				 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
				 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
				 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
				 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
				 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},					    
                                 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
 				 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
				 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
				 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
				 {4,4,4,4,4,4,4,4,4,4,4,4,4,4} };

	for(int i=0;i<11; i++)
	{
		for(int j=0; j<14; j++)
		{
			 areas[i][j] = new Area(type[i][j]);
		}
	}


	for(int i=0; i<11; i++)
        {
            for(int j=0; j<14; j++)
            {
                if(j!=0)
                {
                    areas[i][j]->setLeftArea(areas[i][j-1]);
                }
                if(j!=13)
                {
                    areas[i][j]->setRightArea(areas[i][j+1]);
                }
                if(i!=0)
                {
                    areas[i][j]->setUpArea(areas[i-1][j]);
                }
                if(i!=10)
                {
                    areas[i][j]->setDownArea(areas[i+1][j]);
                }
            }
		}
}

void Board::print()
{
	for(int i=0; i<11;i++)
	{
		for(int j=0; j<14;j++)
		{
			std::cout<<areas[i][j]->getSymbol();
		}
	}
}



#endif

Zamiast :

 type[11][14] = { {4,4,4,4,4,4,4,4,4,4,4,4,4,4},
                                 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
                                 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
                                 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
                                 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
                                 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
                                 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
                                  {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
                                 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
                                 {4,2,2,2,2,2,2,2,2,2,2,2,2,4},
                                 {4,4,4,4,4,4,4,4,4,4,4,4,4,4} };

daj to :

        int num_rows = 14;
        int num_cols = 11;
        int border = 4;
        int middle = 2;

        for (int y = 0; y < num_rows; y++)
        {
            for (int x = 0; x < num_cols; x++)
            {
                if ((x == 0) || (x == num_cols - 1) || (y == 0) || (y == num_rows - 1))

                    type[x][y] = border;

                else

                    type[x][y] = middle;

            }
        }

Mała rada : wszystkie pętle masz ustawione na sztywno konkretnymi liczbami... A co jeżeli kod Ci się rozrośnie i pewnego dnia będziesz chciał mieć o rząd więcej? Pomyśl czy nie warto dać jakąś stałą lub zmienną żeby potem nie szukać przez pół dnia wszystkich miejsc w których będziesz musiał zamienić np 14 na 15... Najlepiej zrobić to wg. mnie na tablicach dynamicznych :

#include <iostream>

using namespace std;

//----------------------------------------------------------

class Board
{

private:

        int **type;
        static const int num_rows = 14;
        static const int num_cols = 11;
        static const int border = 4;
        static const int middle = 2;

public:

        Board();

};

//----------------------------------------------------------

Board::Board()
{

        //----------------------------------------------------

        type = new int* [num_cols];

        for (int x = 0; x < num_cols; x++)
        {
                type[x] = new int [num_rows];
        }

        //----------------------------------------------------

        for (int y = 0; y < num_rows; y++)
        {
            for (int x = 0; x < num_cols; x++)
            {

                if ((x == 0) || (x == num_cols - 1) || (y == 0) || (y == num_rows - 1))

                    type[x][y] = border;

                else

                    type[x][y] = middle;

            }
        }

        //----------------------------------------------------

}

//-----------------------------------------------------------

int main()
{
        Board example;

        return 0;
}