How compiler finds template best match and evaluates expressions - c++11

Question

My question is naive but help me out to understand if my reasoning is correct. Here's the code I develop after watching part of a video conference of Walter E. Brown about metaprogramming. The code works. My question is more about how the compiler matches and evaluates the expressions.
//1 - Matches "simple" type.
template <typename T_>
struct mySizeof
{
static constexpr size_t size = sizeof(T_);
};
//2 - Matches arrays of type T_ and size N.
template <typename T_,size_t N>
struct mySizeof<T_[N]>
{
//3 - What is T_ at this point???
static constexpr size_t size = N * mSize<T_>::size;
};
int main()
{
using int_t = int;
using int_arr = int[10][50][100];
std::cout << mySizeof<int_t>::size << ":" << sizeof(int_t) << std::endl;
std::cout << mySizeof<int_arr>::size << ":" << sizeof(int_arr) << std::endl;
return 0;
}
//Parsing & evaluating int [10][50][100]
// 1.1 - Matches T_ = int[10][50][100]. But there's a better match.
// 1.2 - Better match. T_ = int, N = 10.
// 1.3 - Since [10] was consumed, lets check the remain expression. T_ becomes [50][100]. ???
// 2.1 - Matches T_ = int[50][100]. There's a better match.
// 2.2 - Better match. T_ = int, N = 50.
//....
// 4.1 - It matches. T_ -> int
// 4.2 - Doesn't match.
I just need to understand at this point how compiler evaluates and finds out the best match, and how does it perform argument substitution.

Answer 1

Following your schema
Parsing & evaluating int [10][50][100]
1.1 - Matches T_ = int[10][50][100]. But there's a better match. [right]
1.2 - Better match. T_ = int, N = 10. [wrong: N=10, T_=int[50][100]]
1.3 - Since [10] was consumed, lets check the remain expression. T_ becomes [50][100]. [T_ = int[50][100], see 1.2]
2.1 - Matches T_ = int[50][100]. There's a better match. [right]
2.2 - Better match. T_ = int, N = 50. [wrong: N=50 and T_=int[100]]
....
4.1 - It matches. T_ -> int [right]
4.2 - Doesn't match. [right]
(p.s.: If I'm not wrong, SFINAE isn't involved; only specialization.)
A simple test
#include <iostream>
#include <type_traits>
template <typename T>
struct mySizeof
{ static constexpr std::size_t size { sizeof(T) }; };
template <typename T, std::size_t N>
struct mySizeof<T[N]>
{
static constexpr size_t size { N * mySizeof<T>::size };
using type = T;
};
int main ()
{
using T0 = int[10][50][100];
using T1 = typename mySizeof<T0>::type;
using T2 = typename mySizeof<T1>::type;
using T3 = typename mySizeof<T2>::type;
static_assert( std::is_same<int[50][100], T1>::value, "!" );
static_assert( std::is_same<int[100], T2>::value, "!" );
static_assert( std::is_same<int, T3>::value, "!" );
}