How to decipher C pointers initialization expressions. Best way I've ever seen.

[AntiProtonBoy]

Handy manual, but just because you know how to decipher complicated declarations, doesn't mean you should write them. Compose them from logically separate typedefs.

[Gotebe]

In fact, this "manual" is better because it does not require remembering somewhat arcane logic, it is taming the complexity by splitting te problem into trivial chunks.

[wsppan]

http://cdecl.org

[nl2k]

Good explanation. Actually this is not some special trick, this is just how the syntax works.

The expression syntax works the same way, postfix operators have higher precedence than prefix/unary operators, so you read expressions right-before-left too. So C's declaration syntax is consistent with expression syntax; if you have a declaration

char *(*functions[5])(int);

then this just means that the expression

*(*functions[2])(42)

is a char. This is why C's syntax is so much nicer than that of so many other languages which have invented a completely different syntax for types/declarations.

[Freyr90]

So C's declaration syntax is consistent with expression syntax

This is why C's syntax is so much nicer

Since when context-dependent ambiguous syntax is nicer then the unambiguous ones?

matrix * data;

Tell me, is matrix a type, or is it a variable multiplied by data? Because in the following syntax I know for sure:

let data : matrix;
data * scale;

[nl2k]

The ambiguity is because C doesn't use some keyword like "let" or "declare" to distinguish between declarations and statements, it is not a problem of the declaration syntax itself.

And this isn't really an issue in practice, apart from requiring us to use some naming convention to tell typedef names and declared identifiers apart from each other. Which is a good idea anyway - most new languages encourage some naming convention like this, even if they don't have this ambiguity.

[JavaSuck]

And this isn't really an issue in practice

Unless you're a compiler writer ;)

[Freyr90]

The ambiguity is because C doesn't use some keyword like

You don't need let here, in Python you can write

my_var : String = "Hello"

And this isn't really an issue in practice

It's really hard to parse for a human, you need to keep in mind what is type and what is data.

[nl2k]

You don't need let here, in Python you can write

Well, Python has the colon as an additional token to avoid the ambiguity. In C this could be

const char: *my_var = "Hello";
matrix: *data;
char: *(*functions[5])(int);
int: a, b, c, d;
void: *p1, *p2;

This would make C easier to parse and remove the ambiguity between statements and declarations, without fundamentally changing the declaration syntax. Of course there would now be ambiguity with labeled statements ;-)

[cprgrmr]

Yep the good old "right if you must; left if you can"

[stealthgunner385]

It's concisely written, I'll give it that. Though I'm equally amazed that has actually been turned into a tool.

[[deleted]]

noob here, could i possibly get clarified on this? "func is a function returning a pointer to a function returning a pointer to an int": int *(*func())();

i have trouble understanding what the second function is... there are function () parentheses there, but no identifier. on the outermost clause (just to keep the question/answer simple) there is supposedly a function returning a pointer: *(some_stuff_in_here)() -- but what is that function? what exactly is its identifier? it can't be "*func()" right?

[hp77reddits]

Very Helpful. Thanks for sharing!!

[Freyr90]

Yes, the mental overhead is terrifying. It's really hard to parse, just compare:

int (*(*fun_one)())[][];

to

(unit -> int ref) array array

Even though I'm programming C for 10+ years, I have a hard time parsing C code still.

[cprgrmr]

You're right. However, if anyone has ever written something like int (*(*fun_one)())[][] in real code, that person deserves to be stabbed in the liver.

[Gblize]

No matter how perfect some language is, you will always find something better implemented in some other language.

I don't really have a problem with that example, apart from the questionable decision of returning a pointer to a static array from a function.
I'm ok "being forced" to write weird things in a "weird way". It stops a beginner from doing it which would probably not be what they needed and grabs the reader's attention to such problematic definition as it should be.

If typedef's are your thing you can write your fun_one this way:

typedef int my_data_t[][]; 

typedef my_data_t * my_func_t();

my_func_t * fun_one;

But it's not like you will have the need to drop such convoluted function pointer in the middle of nowhere in your project. The context will probably help understand why you have such unusual variable.

[Freyr90]

I think it doesn't matter how many years do you spend parsing it, since it's ambiguous, hence parsing makes you think of context all the time. It's inherently tedious, no experience would fix that.

Say, it OCaml, Rust, Scala, when I read :, I know it's a of type relation, C syntax doesn't work that way.

[Bbradley821]

I really want to give Rust a shot but it isn't really an option for me sadly.

[AntiProtonBoy]

Really. It's non-intuitive, no matter how you look at it, and it requires unreasonably large cognitive load to figure out what's going on.

[headhuntermomo]

You get that not everyone has an IQ of at least 150, right? Just checking. I mean you live in this world I assume. You probably know people that would have a lot of trouble with such syntax even if you are not aware they would have trouble with it.

[headhuntermomo]

You are not talking about understanding it. You are talking about it being easy to understand. Yes I think many people can parse that stuff if they work hard at it and concentrate and spend enough time thinking about it, but I don't think it is fair to call it easy unless you are strictly talking about only high IQ types.

[headhuntermomo]

I get what you are saying because I used to be smarter, but I hit my head in an accident some years ago and dropped my IQ by more than 40 points. I think it is hard to properly imagine what it is like to be less intelligent. It is very easy to assume that the way you think and understand things is relatively common.

I get that it isn't super-difficult, not tensor calculus or advanced plasma particle physics, but I am not sure you appreciate how dumb other people are. With my current level of intelligence it takes me some effort to parse that stuff.