6 ms·
The key issue with C declarations is that "declarations mirror use" which means that you can interpret them this way: int *p; // dereferencing "p" gets you
by bluetomcat 10y ago
The key issue with C declarations is that "declarations mirror use" which means that you can interpret them this way:
int *p; // dereferencing "p" gets you an "int"
int **q; // dereferencing "q" twice gets you an "int"
char a[10]; // subscripting "a" gets you a "char"
void (*f)(void); // calling f() gives you "void"
People who write the asterisk next to the type often have a hard time understanding this.
- deleted 10y ago[deleted]
- tinco 10y agoI think you have it backwards. People who write the asterisk next to the type understand it just fine, we just don't understand how writing it next to the identifier makes sense. At least, that's how I felt until I read your comment. Now at least I understand why using it that way doesn't drive you absolutely insane. So thanks!
- TickleSteve 10y agoabsolutely wrong. the 'type' is pointer-to-int, the 'name' is 'p', hence 'int* p'. I understand pointers quite well, thankyou....
- bonzini 10y agoAnd "int* p, q" declares to pointers to int, amirite?
- TickleSteve 10y agono. You should only ever declare one thing per line. int* p; int q;
- bonzini 10y agoOnly if you don't know how the thing actually works.
- bluetomcat 10y agoThen how about cases like these: int* a, *b; The language was intentionally designed so that the same operators with the same precedence levels are used in declarations as well as in normal expressions.
- ScottBurson 10y ago> the 'type' is pointer-to-int, the 'name' is 'p', hence 'int* p'. It would be great if the language actually worked that way, because that's the natural way to think about it. Unfortunately, it doesn't. In the simple case of a single pointer variable, we can put the star next to the type and pretend that C works the way we think, but it's a fiction.
- Gankro 10y agoI don't see how anything they said is incorrect. The type is int*, the name is p. C just has this weirdly optimized multiple value decl syntax that for some reason really wants to make it easy to declare an array of int, pointer to int, and function to int all at once instead of making it easy to declare multiple pointers to int. It seems to be a perfectly rational reaction to say "oh this was a stupid idea, let's not take advantage of it". (which is honestly a great way to approach a lot of C's features)
- jotux 10y agoC's comma operator syntax is also weird and, in my experience, many people don't really understand it that well. edit: In reference to the last line: "oh this was a stupid idea, let's not take advantage of it". It's a weird feature that generally makes the code more difficult to understand but people still use it a lot, similar to multiple declarations on a single line with pointers mixed in.
- penguinduck 10y agoMaybe you don't understand it that well because the described usage of a comma is not a comma operator (or any kind of operator).
- imtringued 10y agohttps://en.wikipedia.org/wiki/Comma_operator https://en.wikipedia.org/wiki/Comma_operator
- Someone 10y agoAlso, we have int *p, q; which says "p is a pointer to integer; q is an integer". That's an argument against writing int* p, q; because that suggests that both p and q are pointers to integer. And yes, you can write (IIRC) int q, *p; (See also http://www.stroustrup.com/bs_faq2.html#whitespace http://www.stroustrup.com/bs_faq2.html#whitespace)
- dllthomas 10y agoYRC
- Avernar 10y agoThat's why I declare pointer variables one to a line. Wish the language would work the other way with the asterisk associativity. Mainly because this just looks wrong to me: int *p, *q; typedef int *intp; intp p, q; That just screams that the * belongs to the type and not the variable name.
- jotux 10y agovoid (*fn)(int*) // fn takes a pointer-to-an-int and gives you void Wouldn't this suggest that the type this function takes is `int*`? I've always thought the pointer declaration syntax in C was just an oversight and I get around it's ambitiousness by always declaring variables on their own line.
- bluetomcat 10y agoAs the article says, int-star is an "abstract declarator". An abstract declarator simply omits the name, otherwise it is the same. Therefore, the "canonic" way to write that declaration would be: void (*fn)(int *);
- paxcoder 10y ago>People who write the asterisk next to the type often have a hard time understanding this. Why do you think so?
- Mikhail_Edoshin 10y agoWhat about function declarations? If a function returns a pointer, will you stick the asterisk to the function name? And in a declaration you may omit parameter names entirely, so there's nothing to stick the asterisk to: Foo* bar(Baz*, Qux*, int, int*, int**); I myself do it differently depending on the context. In functions I always stick the asterisk to the type, but if I declare variables, I stick it to the name: Foo* bar(Baz* baz) { Foo *a, b; Baz c, *d; ... }
- bluetomcat 10y agoThe same reasoning applies to function declarations returning pointers: int *f(void); // "*f()" returns "int" and "f()" returns "int *" My habit is to always put a space between the type and the asterisk, regardless of whether there is an identifier: sizeof(int *); x = (char *) y;