Re: indexing elements of a 2D array by pointer for transpose

On Aug 5, 7:32 pm, pc_whocares <pc_whoca...@yahoo.com> wrote:


Just a nit, but what is this line supposed to be doing. (I'm
pretty sure that it doesn't do what you expect.)


    [...]


OK. For starters, neither C nor C++ have multiple dimensioned
arrays---what they do have is arrays of any arbitrary type,
including arrays of arrays. This conditions both the syntax,
and some of the restrictions involved.

For more precision here, I'll introduce a somewhat formal
concept out of the standard: that of an incomplete type. In
C++, you can have incomplete types; the compiler knows that it
is a type, and probably a bit more, but it doesn't know
everything about the type. In particular, with regards to what
interests us here, the compiler does not know the size (number
of bytes) of the type. This is important, because in order to
lay out an array, and calculate indexes into it, the compiler
must know the size. So you can't have an array of an incomplete
type.


Sort of. Technically, you obviously can't because no such thing
exists. Practically, you can create an array of arrays, which
will behave in many respects like a 2D array, BUT... An array
whose size is not known to the compiler is an incomplete type,
so you can't create an array of such arrays. Thus, an
expression like "new double[ n ][ 10 ]" is fine, since this
creates a double[] of double[10]. (I'll use typename[] for an
array of unknown dimensions, an incomplete type, and
typename[n], where n is a compile time constant, for an array of
known dimension n, which is a complete type.) On the other
hand, "new double[i][j]" doesn't work, because that attempts to
create a "double[] of double[]", and array of the incomplete
type double[].

Note too that in the first case (the one that works), the new
expression returns a pointer to the first element of the array.
The first element of the array has type double[10], so we need a
pointer to double[10] (and not to just double). Which results
in the somewhat awkward syntax:
    double (*array1)[ 10 ] = new double[ n ][ 10 ] ;

And if you've understood the above, you know why most C++
programmers will "flatten" the array, using a one dimensional
array of n*m, and calculating the index themselves. Generally
wrapping all of the logic in a class.

Finally, since you don't have multiple dimensional arrays,
there's no syntax to index them. If you have an array of
arrays, you have to index the outer array, which returns the
inner array, which you then index, e.g.: array[i][j].


A couple of comments: first, for what few C++ features you're
using, if the function must be called from C, it's probably not
worth the bother of compiling it with C++. Unless you use
classes and/or some sort of smart pointers (which I would
recommend), just use malloc/free and compile in C. Second: if
you do use C++ features, and compile in C++, you'll need the
extern "C" everywhere, not just in Windows. Also, I presume
that the above is copy/pasted from the header somewhere; "#ifdef
__cplusplus" doesn't make sense in a source file, which will be
compiled as either C or C++, but not as both. For that matter,
you should probably include the header here, so that if there is
any difference between your function definition and the external
declaration, the compiler will tell you about it.


I discussed both problems above. All but the first dimension
must be compiler constants, and the return type is a pointer to
an array of double, not a pointer to double.

I'd just use:
    std::vector< double > tmpArray( n * m ) ;
Most likely, wrapped in a class which allowed the [][] syntax
for indexing.


This could easily be done with std::transform. One thing at a
time, so I won't go into that here, but it's something that you
really should learn fairly quickly. (If I were teaching C++,
you'd probably learn to use std::transform before you learned
how to manipulate C-style arrays.)


That's single indexing. The comma in the [i,j] is a comma
operator; the semantics are to evaluate the first expression
(for side effects), then throw away its value and evaluate the
second expression. And now that you are aware of its existance,
forget it---it's something that should never be used. What you
probably wanted to write is:

    tmpArray[ i ][ j ] = array2d[ j ][ i ] ;

Except that for the reasons explained above, this won't work.

Also, I presume that there is a:
    assert( n * m == arraySize ) ;
at the start of the function, which you forgot. (For that
matter, why pass arraySize at all, since you can easily
calculate it from n and m?)

Supposing that the transformation from column major ([j,i]) to
row major ([i,j]) is intentional, you really have to write
something like:
    tmpArray[ m * i + j ] = array2d[ n * j + i ] ;
(or something along those lines).

Alternatively, you can write two small wrapper classes which
support column major and row major accessing. (The column major
is a bit tricky, as it will require some sort of proxy.)


All that does is assign your pointer to the argument pointer,
which is a local variable, and will disappear when you return
from the function.

You can use std::copy for this, but looking at your code, I
don't think you really need tmpArray at all. Once you've
generated array2D, you don't need the values in array any more,
so you can do the second transformation directly into array.

(But I'm wondering what this function is really supposed to do?
Basically, it transforms array into array2D by scaling, and then
puts a permutated copy of the transformed array2D into the
original array. That doesn't really make sense for a single
function.)


So why return it?


--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
                   Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34