www.digitalmars.com         C & C++   DMDScript  

D - int*[5] array;

reply "Dario" <supdar yahoo.com> writes:
Arrays are declared with the [] after the identifier. This leads to very
clumsy syntax to declare things like a pointer to an array:
    int (*array)[3];
In D, the [] for the array go on the left:
    int[3] *array;        //declares a pointer to an array of 3 ints
    long[] func(int x);        //declares a function returning an array of
longs
which is much simpler to understand.
_____________________________________________________

Doesn't this syntax look strange?
The C code:
    int * array[5];
corresponds to the D code:
    int*[5] array;

You say the second one is easier to understand. I agree but this is
inconsistent: you dereference it with:
    int something = *array[5];
and not with:
    int something = array*[5];
or:
    int something = *[5]array;

In C the declaration was very similar to the dereferencing sintax.
D is inconsistent about it.

((( sorry for my English, that's orrible...)))    ;-)
Jun 08 2002
parent reply "Walter" <walter digitalmars.com> writes:
"Dario" <supdar yahoo.com> wrote in message
news:adt7d4$mb6$1 digitaldaemon.com...

 _____________________________________________________

 Doesn't this syntax look strange?
 The C code:
     int * array[5];
 corresponds to the D code:
     int*[5] array;

 You say the second one is easier to understand. I agree but this is
 inconsistent: you dereference it with:
     int something = *array[5];
 and not with:
     int something = array*[5];
 or:
     int something = *[5]array;

 In C the declaration was very similar to the dereferencing sintax.
 D is inconsistent about it.


Yes, you're right. But D still does allow the [] after the identifier as
well, i.e.:
    int[] foo;
    int foo[];
are both declaring foo to be an array of ints.
Jun 11 2002
parent reply "Dario" <supdar yahoo.com> writes:
 Doesn't this syntax look strange?
 The C code:
     int * array[5];
 corresponds to the D code:
     int*[5] array;

 You say the second one is easier to understand. I agree but this is
 inconsistent: you dereference it with:
     int something = *array[5];
 and not with:
     int something = array*[5];
 or:
     int something = *[5]array;

 In C the declaration was very similar to the dereferencing sintax.
 D is inconsistent about it.





 Yes, you're right. But D still does allow the [] after the identifier as
 well, i.e.:
     int[] foo;
     int foo[];
 are both declaring foo to be an array of ints.


But the first one is the official one: d programmers are all going to use
the first one.
You wrote that "int[]* vector;" is better because it is simpler than "int
(*vector)[];".
But you already use the old sintax for dereferencing. So maybe we should be
able to use the new syntax everywhere (a postfix operator?).
Jun 17 2002
next sibling parent "Walter" <walter digitalmars.com> writes:
"Dario" <supdar yahoo.com> wrote in message
news:aekb3c$1hsb$1 digitaldaemon.com...

 But the first one is the official one: d programmers are all going to use
 the first one.


Yes.


 You wrote that "int[]* vector;" is better because it is simpler than "int
 (*vector)[];".


Yes.


 But you already use the old sintax for dereferencing. So maybe we should


be

 able to use the new syntax everywhere (a postfix operator?).


Sometimes, complete consistency may not be worth it <g>.
Jun 18 2002
prev sibling parent reply "Juan Carlos Arevalo Baeza" <jcab roningames.com> writes:
"Dario" <supdar yahoo.com> wrote in message
news:aekb3c$1hsb$1 digitaldaemon.com...


 But you already use the old sintax for dereferencing. So maybe we should


be

 able to use the new syntax everywhere (a postfix operator?).


   Hmmm... The old syntax IS a postfix operator. Kinda.

   Anyway, I never understood why some people think that defining a variable
and using it must use the same syntax. I always loved Pascal-type syntax for
declaring:

f: pointer to array of int;
g: array[1..7] of pointer to array[1..10] of array[1..2] of float;

Salutaciones,
                         JCAB
Jun 18 2002
parent reply "OddesE" <OddesE_XYZ hotmail.com> writes:
"Juan Carlos Arevalo Baeza" <jcab roningames.com> wrote in message
news:aenq65$2l2t$1 digitaldaemon.com...

 "Dario" <supdar yahoo.com> wrote in message
 news:aekb3c$1hsb$1 digitaldaemon.com...


 But you already use the old sintax for dereferencing. So maybe we should


 be

 able to use the new syntax everywhere (a postfix operator?).


    Hmmm... The old syntax IS a postfix operator. Kinda.

    Anyway, I never understood why some people think that defining a


variable

 and using it must use the same syntax. I always loved Pascal-type syntax


for

 declaring:

 f: pointer to array of int;
 g: array[1..7] of pointer to array[1..10] of array[1..2] of float;

 Salutaciones,
                          JCAB




I agree.
Verbose as it is, it is very easy to understand and
it reads the 'right' way (pun intended). However it
is totally inconsistant for C and therefore also for D.

I think complex declarations such as these prove
that in the end, pascal's left-to-right declarations
make much more sense than C's right-to-left ones...
The fact that Walter and everyone on this group still
didn't come up with a C-style syntax for declaring
compex pointer to arrays of pointers to etc, that is
really clear and consistant, is something that should
inspire some serious thought.


--
Stijn
OddesE_XYZ hotmail.com
http://OddesE.cjb.net
_________________________________________________
Remove _XYZ from my address when replying by mail
Jun 26 2002
parent "Juan Carlos Arevalo Baeza" <jcab roningames.com> writes:
"OddesE" <OddesE_XYZ hotmail.com> wrote in message
news:afd93d$2d7k$1 digitaldaemon.com...

 "Juan Carlos Arevalo Baeza" <jcab roningames.com> wrote in message
 news:aenq65$2l2t$1 digitaldaemon.com...


 f: pointer to array of int;
 g: array[1..7] of pointer to array[1..10] of array[1..2] of float;


 I agree.
 Verbose as it is, it is very easy to understand and
 it reads the 'right' way (pun intended).


   Exactly!


 However it
 is totally inconsistant for C and therefore also for D.


   What you mean, I believe, is that type declarations are not written
exactly the same way as using objects of the type. Now, I've never
understood why some people consider it that important.

   Clarity and lack of ambiguity are much better properties, IMHO.

   Still, it is not perfect. For example, I love the fact that (unlike in
LX) the name is separate from the type expression. But it has a problem with
initializers:

f = NULL: pointer to array of int;
f: pointer to array of int = NULL;

   The second form sounds a little better, maybe (easier to parse?), but it
breaks with multiple-variable initialization:

f = NULL, g = &myarray: pointer to array of int;
f, g: pointer to array of int = NULL, &myarray; // Ugh!

   And also, I still like using puntuation rather than keywords wherever
possible (it's easier to spot at a glance):

f = NULL, g = &myarray: *[]int; // Better?

   Of course, this deviates from the general C/C++ norm, which makes it
maybe not desirable to D. It's just a matter of weighing the advantages and
disadvantages, which is Walter's prerogative.


 I think complex declarations such as these prove
 that in the end, pascal's left-to-right declarations
 make much more sense than C's right-to-left ones...
 The fact that Walter and everyone on this group still
 didn't come up with a C-style syntax for declaring
 compex pointer to arrays of pointers to etc, that is
 really clear and consistant, is something that should
 inspire some serious thought.


   Definitely.

Salutaciones,
                         JCAB
Jun 27 2002