Szabolcs Borsanyi wrote:
> Deal all,
>
> The type
>
> typedef double ***tmp_tensor3;
>
> is meant to represent a three-dimensional array. For some reasons the
> standard array-of-array-of-array will not work in my case.

/* BEGIN new.c */

#include <stdio.h>

#define DIM_1 2
#define DIM_2 3
#define DIM_3 4

typedef double tmp_tensor3[DIM_2][DIM_3];

void func(tmp_tensor3 *d3array);

int main(void)
{
double array[DIM_1][DIM_2][DIM_3];
int c1, c2, c3;

for (c1 = 0; c1 != DIM_1; ++c1)
for (c2 = 0; c2 != DIM_2; ++c2)
for (c3 = 0; c3 != DIM_3; ++c3) {
array[c1][c2][c3] = c1 + c2 + c3 + 0.5;
}
func(array);
return 0;
}

void func(tmp_tensor3 *d3array)
{
int c1, c2, c3;

for (c1 = 0; c1 != DIM_1; ++c1) {
for (c2 = 0; c2 != DIM_2; ++c2){
for (c3 = 0; c3 != DIM_3; ++c3) {
printf("%f ", d3array[c1][c2][c3]);
}
putchar('\n');
}
putchar('\n');
}
putchar('\n');
}

/* END new.c */


--
pete

Szabolcs Borsanyi wrote:
> So the question is still there: how to legally convert from (double***) to
> (double * const * const *) and then that to (double const * const * const *).
> I am worried about the compatibility of the types.

Since you are casting from a non-constant pointer to a constant pointer,
you can perform the cast safely. This applies to each layer of
indirection. For example,

typedef double * const * const * tensor3;
typedef const double * const * const * const_tensor3;

double ***ppp_tensor;
tensor3 T = (tensor3)ppp_tensor;
const_tensor3 cT = (const_tensor3)T;

const int M, N, K; // dimensions of data cube
int i, j, k; // variables of iteration
for (i = 0; i < M; i++) {
double * const * const row = T[i];
for (j = 0; j < N; j++) {
double * const col = row[j];
for (k = 0; k < K; k++) {
double el = col[k];
}
}
}

for (i = 0; i < M; i++) {
const double * const * const row = cT[i];
for (j = 0; j < N; j++) {
const double * const col = row[j];
for (k = 0; k < K; k++) {
const double el = col[k];
}
}
}

I believe that satisfies your questions.

--
Andrew Kerr

Andrew Kerr wrote, On 30/05/08 19:03:
> Szabolcs Borsanyi wrote:
>> So the question is still there: how to legally convert from
>> (double***) to
>> (double * const * const *) and then that to (double const * const *
>> const *).
>> I am worried about the compatibility of the types.
>
> Since you are casting from a non-constant pointer to a constant pointer,
> you can perform the cast safely. This applies to each layer of
> indirection. For example,

<snip>

There is a good discussion of the issues and the reason for the
conversion not being explicit in question 11.10 of the comp.lang.c FAQ
at http://c-faq.com/
--
Flash Gordon

Flash Gordon <spam@flash-gordon.me.uk> writes:
> Andrew Kerr wrote, On 30/05/08 19:03:
>> Szabolcs Borsanyi wrote:
>>> So the question is still there: how to legally convert from
>>> (double***) to
>>> (double * const * const *) and then that to (double const * const *
>>> const *).
>>> I am worried about the compatibility of the types.
>> Since you are casting from a non-constant pointer to a constant
>> pointer, you can perform the cast safely. This applies to each layer
>> of indirection. For example,
>
> <snip>
>
> There is a good discussion of the issues and the reason for the
> conversion not being explicit in question 11.10 of the comp.lang.c FAQ
> at http://c-faq.com/

I think you mean "not being implicit".

--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"