If you have written some assembler, you will see where C is coming from. It just occurred to me that most early C programmers were probably proficient In assembly.
*some_index[arr]
(though obviously not saying you should), but you can't declare: char *5[arr];
Obviously there's good reasons for that, but then you have "declarations mirror use, except when there's good reason not to", which basically brings you back to the original question.Isn't that exploiting a quirk of the operator's definition, rather than how the operator is intended to be used?
Edit: I guess I'll also note here just for fun that while
char [5]arr;
seems reasonable enough, char [4][5]arr1;
char[5][4] arr2;
seems less so.To me understanding the actual types involved is more important than getting the declaration to look some specific way. (So I always jammed the star next to type and did whatever else I though would most ease expressing types)
I am also the kind of developer who who have declared it as:
std::array<std::string, X> arr;
or
std::vector<std::string> arr;
depending on if X was known at compile time. Because I want to give the compiler as many chances to call out my mistakes as possible.
char*[X] arr;
You read strictly left to right: char pointer array of size X called arr. Basically, it takes a simple type (char in this case) and for each thing to the right, wraps it in something. You could read it as: given a char, we have a pointer to it, and an array of size X of these pointers.It would be interesting if the use did "mirror" declaration:
arr[5]*
That is, take element 5 of arr and derefence it.Just some random thoughts...
That wouldn't play well with pointers to arrays and pointers to functions:
int (*pa)[X]; // int(*)[X] pa;
int (*fp)(void); // int(*)(void) fp;
Here is how I designed the type declaration syntax in my own language, Quaint (https://github.com/bbu/quaint-lang): pa: ptr(int[3]); // int (*pa)[3]
fp: fptr(): int; // int (*fp)(void)
arr: int[5]; // int arr[5]
p: ptr(int); // int *p
pp: ptr(ptr(int)); // int **pp
arrp: ptr[5](int); // int *p[5]
You basically have the identifier first, and then a recursive expression which uses mostly function-call-like expressions in order to nest recursive types.That does not even English.
Preferring 'char ٭arr[X]' over '٭char[X] arr' seems arbitrary to me. I see no reason the 'declaration mirror use' principle can differentiate between the two.
Personally I prefer the latter since it makes it easy to separate the type from the identifier.
The "type" is actually a list of storage class specifiers (static, extern, auto, register, typedef, _Thread_local), type qualifiers (const, volatile, restrict) and type specifiers (int, char, float, double, signed, unsigned, long, short, void). Imagine the soup of keywords that would have to be at the deepest level of the expression:
static const volatile unsigned char *arr[X];
// vs
*static const volatile unsigned char[X] arr; static const volatile *unsigned char[X] arr;
Or, because signedness should be a property of the type, not an arbitrary modifier: static const volatile *char[X] arr;What is this dirt after char and before char? This wouldn't even compile.
Who's use? The compiler's or the programmer's? Can you elaborate? Sorry if this silly question but I've scratched my head enough on hearing that phrase that I thought I would ask. Cheers.
int **p; // declares "p" as a pointer to a pointer to int
int x = **p; // the "**p" expression mirrors the declaration and its type is "int"
This is true even for functions: int *f(int a); // declares a function which takes an int and returns a pointer to int
int res = *f(3); // the "*f(3)" expression mirrors the declaration and its type is "int"
Arrays are obvious when looked that way: int arr[5][5];
int elem = arr[1][2]; // the "arr[1][2]" expression mirrors the declarationI have read that the reason for this declaration syntax is that it was easier form compilers and compiler writers to parse.
How does this declaration syntax facilitate parsing exactly? I fail to see why this is.
(*arr[i])(42)
means that you can use pretty much the same machinery to parse int (*arr[SIZE])(int a)This sounds really odd to me. I can see, and others have pointed this out in the comments, too, that DMU might facilitate building a compiler for such a language and reuses several operators. However, I am not sure whether I like this goal from a person-centric perspective.
Experts might be used to matching declaration and use structures in their code, maybe to make it more 'symmetric', but I am sceptical whether this match is actually quite 'expensive' when developing code with many people of different skills.
Use and declaration are differnt concepts, and as such should have different representations (i.e., syntactically), otherwise you might introduce synonym defects (i.e., ambiguities, where it becomes hard to understand what somebody means). I found that some of my colleagues and students had a hard time to learn what pointers are about (and I believe this is a fairly common phenomenon, that people find pointers in C hard to grasp), because the asterisk is used both in declaration and in dereferencing. I found that some of my students got the concept more easily after I introduced a couple of macros:
#include "stdio.h"
#define IntPointer int*
#define value_of(ptr) *ptr
#define address_of(v) &v
int main() {
int a = 42;
IntPointer p = address_of(a);
printf("%i\n", value_of(p));
return 42;
}
The above code has no other purpose than to separate the concepts verbally, so that they can be reasoned about explicitly. This can be achieved in other ways, for example, in C++ I tend to use templates or classes to abstract the pointer syntax away. Of course, I am aware that using classes introduces overhead and this technique is not necessarily feasible when you need as much performance as you can get.This also underlines my original point to place the asterisk on the datatype rather than on the identifier, because the #define wouldn't make sense otherwise.
In summary, I was unaware that DMU was a design goal, but I suspect it to make the language more difficult to learn, code harder to read, altough this effect might not be an issue for experts.
I am not trying to convince anybody that DMU is "bad", but I am interested in the actual properties. Everybody making claims for readability owes the community an empirical evaluation. Disclaimer: I am currently working on a research project about program comprehension, including some eyetracking and FMRI work, providing exactly such evaluations. :)
I am going to be that person :-)
One phrase – "declarations mirror use". In a declaration, you use the same set of operators around the declared object that you would use in a normal expression. All of these operators (asterisk, `[]` and `()`) have the exact same precedence and associativity as in the rest of the language. The type specifier(s) on the left is the final type of the expression that you get after applying all of the operators in the correct order as per the precedence/associativity rules.
So when you see:
You identify the identifier first: `arr`. Then, because `[]` takes precedence over the asterisk, you say that `arr` is an array (of size X) of pointers to `char`. In other words, the expression `*arr[some_index]` is of type `char`.