[сcode]
uint64_t* GetArray()
{
uint64_t* timestampsTable = new[NUMBER_OF_MESSAGES_FOR_SEND][FIELDS_CONTAING_TIMESTAMPS];
return timestampsTable;
}

uint64_t* timeStamps = GetArray();
printf("R:m %8lu r %ld\n", i, timeStamps[i][RECEIVE_TIMESTAMP]);
[/сcode]

Как описать с помощью typedef, удобный доступ к элементу двумерного массива через указатель?
Не хотелось бы ползать по памяти и не вычислять значение.

Здравствуйте, CronAcronis, Вы писали:

[сcode]
CA>uint64_t* GetArray()
CA>{
CA> uint64_t* timestampsTable = new[NUMBER_OF_MESSAGES_FOR_SEND][FIELDS_CONTAING_TIMESTAMPS];
CA> return timestampsTable;
CA>}

CA>uint64_t* timeStamps = GetArray();
CA>printf("R:m %8lu r %ld\n", i, timeStamps[i][RECEIVE_TIMESTAMP]);
[/сcode]
Двумерный массив — это массив массивов. Поэтому, на выбор — или трактуй как одномерный и вычисляй линейный индекс, либо трактуй как двумерный

typedef uint64_t TRow[FIELDS_CONTAINING_TIMESTAMPS];
typedef TRow TMatrix[NUMBER_OF_MESSAGES_FOR_SEND];

TRow* GetMatrix()
{
    return new TMatrix;
    // либо
    return new TRow[number_of_messages]; // может быть переменной величиной
}

TRow* timestamps = GetMatrix();
uint64_t timestamp = timestamps[i][RECEIVE_TIMESTAMP];

Но для этого, естественно, надо знать FIELDS_CONTAINING_TIMESTAMPS на стадии компиляции.

CA>Как описать с помощью typedef, удобный доступ к элементу двумерного массива через указатель?
CA>Не хотелось бы ползать по памяти и не вычислять значение.

Можно сделать прокси

template<class T> struct onedim
{
    int sx;
    T* data;
    onedim(int sx, T* data) : sx(sx), data(data) {}
    T& operator[](int x) { assert(0<=x && x<sx); return data[x]; }
};
template<class T> struct twodim
{
    int sx, sy;
    T* data;
    twodim(int sx, int sy, T* data) : sx(sx), sy(sy), data(data) {}
    onedim<T> operator[](int x) const { assert(0<=x && x<sx); return onedim<T>(sy, data+x*sy); }
    // здесь вместо onedim можно сразу возвращать T* - но пропадёт возможность проверки индекса
};
template<class T> struct threedim
{
    int sx, sy, sz;
    T* data;
    threedim(int sx, int sy, int sz, T* data) : sx(sx), sy(sy), sz(sz), data(data) {}
    twodim<T> operator[](int x) const { assert(0<=x && x<sx); return twodim<T>(sy,sz, data+x*sy*sz); }
};

Ах, да! Нужно же ещё позаботиться о владении памятью.
Тогда вместо T* надо boost::shared_array<T>. И пока жив хоть один прокси, массив будет жить.