initializer_list jako odpowidnik 2d tablicy

Czesc, mam problem z napisaniem konstruktora, ktory bedzie tworzyl mi , czyli rozwiazane problem 15 puzzli (0 - puste pole)

1 | 2 | 3 | 4
5 | 6 | 7 | 8
9 |10 | 11| 12
13|14 | 15| 0

Zwykly konstruktor napisalem i wyglada tak.

fifteen::fifteen( )
{
	size_t value = 1;
	for(size_t i = 0; i < dimension; ++i)
	{
		for(size_t j = 0; j < dimension; ++j)
			{table[i][j] = value;
			value++;}
	}

	table[dimension-1][dimension-1] = 0;
}

przykladowe wywolani

fifteen f{ { 1, 3, 4, 12 }, { 5, 2, 7, 11 }, { 9, 6, 14, 10 }, { 13, 15, 0, 8 } } ;

Ale teraz nie wiem jak napisac taki konstruktor ktorego naglowek ma wygladac tak

fifteen::fifteen( std::initializer_list< std::initializer_list< size_t > > init )

Rzeczy z klasy fifteen:

class fifteen
{
private: 
   static constexpr size_t dimension = 4;
      
   static_assert( dimension > 1, "dimension must be two at least" );

   using position = std::pair< size_t, size_t > ;

public:
   size_t table [ dimension ][ dimension ];
      // We use the numbers 1 .. dimension*dimension-1 for the tiles,
      // and 0 for the open place.

   size_t open_i;
   size_t open_j;
      // Position of the open place. Use matrix notation, i is row, 
      // j is column

http://en.cppreference.com/w/cpp/utility/initializer_list

tutaj wszystko jest

Ja mam takie głupie pytanie: po co ci taki konstruktor?
Będziesz wpisywał każdy układ 15ki ręcznie do kodu?

Dostalem od znajomego taki kod moglby mi ktos pomoc w ogarnieciu go

fifteen::fifteen( std::initializer_list< std::initializer_list< size_t > > init )
{
	size_t i = 0, j = 0;

	for(auto it_i = init.begin(); i < dimension ; ++i, ++it_i)
	{
		j = 0;
		for(auto it_j = (*it_i).begin(); j < dimension  ; ++j, ++it_j)
		{
			table[i][j] = *it_j;
			if(*it_j == 0) open_i = i, open_j = j;
		}
	}
}

Nie do konca wiem czemu robimy tak:
1.auto it_j = (*it_i).begin();
2.table[i][j] = *it_j;
3.if(*it_j == 0) open_i = i, open_j = j;

Tak juz pisalem ma to tworzyc rozwiazny problem 15 puzzli

#include <iostream>
#include <map>
#include <unordered_map>
#include <tuple>
#include <set>
#include <sstream>
#include <vector>
#include <algorithm>
#include <thread>
#include <chrono>
#include <ctime>
#include <functional>


struct A
{
	A(std::initializer_list<std::initializer_list<size_t>> init);

	static constexpr size_t dimension = 4;

	size_t table [ dimension ][ dimension ];
};

A::A(std::initializer_list<std::initializer_list<size_t>> init)
{
	size_t dim = 0;
	size_t dimInner = 0;
	auto startIt = std::begin(init);
	do {
		auto startInnerIt = std::begin(*startIt);
		do {
			table[dim][dimInner] = *startInnerIt;
			std::advance(startInnerIt, 1);
		} while(++dimInner < dimension);
		std::advance(startIt, 1);
		dimInner = 0;
	} while(++dim < dimension);

	for(size_t i = 0 ; i < dimension ; ++i) {
		for(size_t j = 0 ; j < dimension ; ++j) {
			std::cout << table[i][j] << std::endl;
		}
	}
}

int main()
{

	A a { { 1, 3, 4, 12 }, { 5, 2, 7, 11 }, { 9, 6, 14, 10 }, { 13, 15, 0, 8 } } ;

	return 0;
}

https://wandbox.org/permlink/6CDuVgfXJlYRFtRS

nie patrzyłem czy są błędy, ale output chyba ok

xarix napisał(a):

Dostalem od znajomego taki kod moglby mi ktos pomoc w ogarnieciu go

fifteen::fifteen( std::initializer_list< std::initializer_list< size_t > > init )
{
	size_t i = 0, j = 0;

	for(auto it_i = init.begin(); i < dimension ; ++i, ++it_i)
	{
		j = 0;
		for(auto it_j = (*it_i).begin(); j < dimension  ; ++j, ++it_j)
		{
			table[i][j] = *it_j;
			if(*it_j == 0) open_i = i, open_j = j;
		}
	}
}

Nie do konca wiem czemu robimy tak:
1.auto it_j = (*it_i).begin();
2.table[i][j] = *it_j;
3.if(*it_j == 0) open_i = i, open_j = j;

Tak juz pisalem ma to tworzyc rozwiazny problem 15 puzzli

1.auto it_j = (*it_i).begin(); -> it_i to iterator po 4 listach {}, wejście w małą listę to *it_i, a begin() tworzy iterator do właśnie tej małej listy;
2.table[i][j] = *it_j; -> zapisujesz element z małej listy do tablicy;
3.if(*it_j == 0) open_i = i, open_j = j; -> nie przyglądałem się tym zmiennym

edit:
formatowanie na tym forum nie pozwala na udzielanie odpowiedzi na tak delikatne pytania jak dereferencja iteratorów, mam nadzieję, że przywrócona zostanie stara wersja