Скорость чтения массива по "колонкам" ?

int n[4][3]{1,2,3, 4,5,6, 7,8,9, 0,1,2};
for (int r = 0; r < 4; r++)
{
    n[r][2];
}

int n[4][3]{1,2,3, 4,5,6, 7,8,9, 0,1,2};
int* pn = &n[0][0] - 1;
for (int d = 0; d < 4; d++)
{
    pn += 3;
    *pn;
}

///----------------------------------------------------------------------------|
/// Стенд для замера количество тактов на каждом из двух участков кода.
/// Делается 1000 000 000 проходов для каждого участка.
/// Выбирается только лучший(меньшее количество тактов) результат.
///----------------------------------------------------------------------------:
#include <stdio.h>
#include <conio.h>
 
///----------------------------------------------------------------------------|
/// Мерилка тактов проца.
///----------------------------------------------------------------------------:
typedef unsigned long long ull;
inline ull rdtsc()
{   
#ifdef __BORLANDC__ 
#endif
 
#ifdef _MSC_VER
    unsigned clock = 0;
    __asm rdtsc;
    __asm mov[clock], eax;
    return clock;
#endif
 
#ifdef __GNUC__
    unsigned int lo, hi;
    asm volatile ("rdtsc\n" : "=a" (lo), "=d" (hi));
    return ((ull)hi << 32) | lo;
#endif
}
 
 
///----------------------------------------------------------------------------|
/// Для удобства.
///----------------------------------------------------------------------------:
#define START_PERFOMANCE  ull t1 = rdtsc(); static ull ss_  = 0xffffffff;\
    bool b = false
#define END_PERFOMANCE ull v  = rdtsc(); v -= t1;\
    if(ss_ > v){ b = true; ss_ = v;}
 
///----------------------------------------------------------------------------|
/// variant_1.
///----------------------------------------------------------------------------:
ull variant_1()
{   int nw = 0;
 
START_PERFOMANCE;//=============================//
int n[4][3]{1,2,3, 4,5,6, 7,8,9, 0,1,2};
for (int r = 0; r < 4; r++)
{
    n[r][2];
}
END_PERFOMANCE;//===============================//
 
    if(b)
    {   printf ("variant_1: ");
        printf ("%10u \n",  (unsigned)ss_);
        b = false;
    }
 
    return ss_;
}
 
///----------------------------------------------------------------------------|
/// variant_2.
///----------------------------------------------------------------------------:
ull variant_2()
{   int  nw = 0;
 
START_PERFOMANCE;//=================================================//
int n[4][3]{1,2,3, 4,5,6, 7,8,9, 0,1,2};
int* pn = &n[0][0] - 1;
for (int d = 0; d < 4; d++)
{
    pn += 3;
    *pn;
}
END_PERFOMANCE;//===================================================//
 
    if(b)
    {   printf ("variant_2: ");
        printf ("%10u \n",  (unsigned)ss_);
        b = false;
    }
 
    return ss_;
}
 
///----------------------------------------------------------------------------|
/// Start.
///----------------------------------------------------------------------------:
int main()
{   ull m,c;
 
    //-------------------------------|
    // Quiet, testing!               |
    //-------------------------------:
    for(int i = 0; i < 1000000000; ++i)
    {   c = variant_1();
        m = variant_2();
    }
 
    //-------------------------------|
    // Banners is redy...            |
    //-------------------------------:
    const char* str[] = {"WIN <<<--!!!", "looser...", "friendship won!"};
    int i1, i2;
    (m > c) ? (i1 = 0, i2 = 1) : 
              ((m == c)?(i1 = 2, i2 = 2) : (i1 = 1, i2 = 0));
 
    //-------------------------------|
    // Finish result.                |
    //-------------------------------:
    printf ("\nFinish the race-------------------:\n");
    printf ("variant_1: %u - ", (unsigned)c);
    printf ("%s\n", str[i1]);
    printf ("variant_2: %u - ", (unsigned)m);
    printf ("%s\n", str[i2]);
 
    //-------------------------------|
    // Show efficiency.              |
    //-------------------------------:
    double ef = 100.0/double(c) * double(m) - 100.0;
    printf ("\nProfitable variant_1: %2.2f%%\n\n",  ef);
 
    //_getch();
    return 0;
}

n[r][2];

pn += 3;
*pn;

n[r];
// то есть равнозначно ЛИ можно записать и так ?
*(&n + r)

int n[100200300][3];
std::chrono::time_point<std::chrono::system_clock> start, end;
start = std::chrono::system_clock::now();
for (int r = 0; r < 100200300; r++)
{
    n[r][2];
}
end = std::chrono::system_clock::now();
std::cout <<
    std::chrono::duration_cast<std::chrono::nanoseconds>(end-start).count()
<< std::endl;

for (int r = 0; r < 100200300; r++)
{
    n[r][2] = r;
}

#pragma comment(linker, "/STACK:число_байт")

int n[100200300][3];
std::chrono::time_point<std::chrono::system_clock> start, end;
for (int d = 0; d < 10; d++)
{
    start = std::chrono::system_clock::now();
    for (int r = 0; r < 100200300; r++)
    {
        n[r][2] = r;
    }
    end = std::chrono::system_clock::now();
    __int64 result = std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();
    std::cout << result << " ";
}
std::cout << std::endl;
 
int* pn = &n[0][0] - 1;
for (int d = 0; d < 10; d++)
{
    start = std::chrono::system_clock::now();
    for (int r = 0; r < 100200300; r++)
    {
        pn += 3;
        *pn = r;
    }
    end = std::chrono::system_clock::now();
    __int64 result = std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();
    std::cout << result << " ";
}
std::cout << std::endl;

_asm
{
  lea esi,[n+8]
  xor ecx,ecx
  mov ecx,100200300
next:
  mov [esi],ecx
  add esi,12
  loop next
}