C++ - nadanie wartości tablicy dwuwymiarowej

Zadeklarowałem tablicę dwuwymiarową

 
int SiatkaKlocka[4][4] = {0};

dlaczego nie mogę nadać jej wartości w ten sposób

SiatkaKlocka[4][4] = {
{ 0, 1, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 1, 0, 0 },
};
 

Proszę o pomoc.

bo deklarując tablicę zainicjowałeś już jej wartość elementu 0,0

A nie mogę potem w ten sposób zmieniać jej wartości?

Nie, nie możesz.

Z moich prób wynika, że można zrobić co najwyżej coś takiego

    int tablica[2][2];
    memcpy(tablica, (const int[2][2]){{1,2},{3,4}}, 4*sizeof(int));

ale jest to strasznie brzydkie i pewnie może powodować problemy.

skorzystaj z std::array albo std::vector

std::array<std::array<int, 4>, 4> tablica;
tablica = { {
	{ { 0, 1, 0, 0 } },
	{ { 0, 1, 0, 0 } },
	{ { 0, 1, 0, 0 } },
	{ { 0, 1, 0, 0 } },
} };

Jednakże, nie powinieneś zmieniać zawartość całej tablicy, jeżeli zmieniasz tylko kilka elementów.

Jak się uprzesz to możesz sobie napisać funkcję, która w wygodny sposób będzie uzupełniać tablicę (niestety nie można przeładować operator= poza klasami), ale po co jeśli możesz użyć wygodniejszego std::array tak jak pokazał Aux?

Przerost formy nad treścią:

template<typename L, typename R>
void fillWith(L& l, R const& r);

namespace b = boost;
template<typename L, typename R>
void fillWithImpl(L& l, R const& r, true_type){

	for(auto&& p: b::make_iterator_range(b::make_zip_iterator(b::make_tuple(begin(l), begin(r))),
										b::make_zip_iterator(b::make_tuple(end(l), end(r))))){
		fillWith(p.get<0>(), p.get<1>());
	}
}

template<typename L, typename R>
void fillWithImpl(L& l, R const& r, false_type){
	copy(begin(r), end(r), begin(l));
}

template<typename L, typename R>
void fillWith(L& l, R const& r){
	typedef typename remove_reference<L>::type l_t;
	fillWithImpl(l, r, integral_constant<bool,(rank<l_t>::value > 1)>{});
}

template<typename L, typename R>
void fillWith(L& l, initializer_list<R> r){
	typedef typename remove_reference<L>::type l_t;
	fillWithImpl(l, r, integral_constant<bool,(rank<l_t>::value > 1)>{});
}

template<typename L, typename R>
void fillWith(L& l, initializer_list<initializer_list<R>> r){
	typedef typename remove_reference<L>::type l_t;
	fillWithImpl(l, r, integral_constant<bool,(rank<l_t>::value > 1)>{});
}

Działanie: http://melpon.org/wandbox/permlink/OWIFIshragxpW82p

Dziękuję wszystkim za odpowiedź poradziłem sobie z kodem Auxa, ale mam jeszcze jedno takie pytanie, piszę grę Tetris i chciałbym, żeby gracz mógł wybrać ile pól będzie miała plansza, a tworząc normalną tablicę muszę od razu podać ile będzie miała elementów lub stworzyć zmienną statyczną co odpada. Da się jakoś to ominąć?

Można jeszcze tak:

#include <stdio.h>

struct Siatka { int Klocka[4][4]; };

int main()
  {
   struct Siatka siatka={{{0}}};
   
   printf("%d\n",siatka.Klocka[1][1]);
   
   siatka=(struct Siatka)
     {
	     {
	        { 0, 1, 0, 0 },
	        { 0, 1, 0, 0 },
	        { 0, 1, 0, 0 },
	        { 0, 1, 0, 0 },
	     }
     };
   printf("%d\n",siatka.Klocka[1][1]);
 
   return 0;
  }

http://ideone.com/hHHrg3