Everything you need to know about pointers in C (2010) | Hacker News Reader

Everything you need to know about pointers in C (2010)

boredzo.org

26 pointsank_the_elder24 comments

The time [0] I found out about ptr_b in

  int* ptr_a, ptr_b;

isn't actually initialized as a pointer I changed all my C code to marking * before the variable name, fun times. It's helpful to think int as the base type and * the indicator of functionality like [] and ().

Also just found out the author was the developer of Adium [1], which is one of my favorite softwares (best logo) on macOS.

[0] http://c-faq.com/decl/charstarws.html

[1] https://adium.im/

Besides writing

  "int *p"

instead of

  "int* p"

I also always use one line per variable declaration, which should avoid confusion when the first style is used. But that's my personal preference.

Edit: corrected code quotation.

When quoting code, leave a line and indent by two spaces.

Sorry, will do so in the future. Thx.

"int* p" really grinds my gears

I used to use that years ago! I had to stop when everyone moved over to Facebook Chat (what became Messenger) and eventually made a breaking change Adium couldn't support.

> void pointers are incremented or decremented by 1 byte.

No, void pointer arithmetic is not allowed by the C standard: https://stackoverflow.com/questions/3523145/pointer-arithmet...

An unfortunate typo there: void pointer arithmetic is not allowed.

Oops! Fixed, thanks.

That answer does mention that GCC permits it as an extension. If the author uses GCC, maybe that’s where the confusion comes from?

But then he also writes that "sizeof(void) is illegal".

OTOH, GCC documentation says "sizeof is also allowed on void and on function types, and returns 1".

By C half-assedly trying to make "* " part of the name, just so you can use "* ptr" everywhere like it is an actual variable name, you get confusions such as this.

First "foo_ptr's type is int * ", but then "The pointer has a type, too, by the way. Its type is int.".

I also refuse to agree with "An int * * 's type is int * ". :)

But I guess "the type of `* ptr` is int, the type of `ptr` is int * " would be even more confusing.

It's a pretty bad syntax.

A demonstration of a declaration statement where the asterisk operator binds to an identifier rather than to a type:

    int my_int, *my_ptr, my_other_int;

A demonstration of a different declaration where the asterisk operator does not bind to an identifier, as an identifier isn't even needed:

    extern void my_function(int*, char*);

So the real answer is that it depends on what you're doing. Terribly clunky.

Interestingly the D programming language mostly keeps C's syntax, but handles multiple declarations differently. https://dlang.org/spec/declaration.html#declaration_syntax

int array[] = {...}

1[array] == array[1]

Now add in some poorly named variables for some real fun

https://github.com/Droogans/unmaintainable-code#cs-eccentric...

> A pointer is a memory address.

This is an amazingly wrong statement. In assembly you deal with memory addresses. Pointers in C are a much higher level abstraction.

> On current mainstream Intel processors, it occupies four bytes of memory (because an int is four bytes wide).

This depends on the compiler as well as the processor.

>This depends on the compiler as well as the processor.

Yes. On x64 compilers targeting 64bit cpus, the following prints 8 instead of 4:

  #include <iostream>
  int main () {
      std::cout << sizeof(int*) << std::endl;
  }

Posting C++ in a thread about C is odd. In C it's:

    #include <stdio.h>

    int main(void)
    {
      printf("%zu\n", sizeof (int *));
      return 0;
    }

There's a double-quote character missing.

Thanks. I suck at posting from my phone. Edited.

The article talks about the size of the pointee in memory though, not the size of the pointer.

An 'int' is usually 4 bytes wide when compiling for 64-bit ISAs (at least I haven't seen situations yet where this isn't the case, my experience is limited to x86 and ARM though). Modern C fixes this ambiguity with sized integer types (e.g. int32_t vs int64_t).

>The article talks about the size of the pointee in memory though, not the size of the pointer.

Yes, you're right about the article's text. When I read gp ChrisSD's comment in isolation where he quotes ">A pointer is a memory address" -- followed immediately by him quoting ">On current mainstream Intel processors, _it_ occupies four bytes of memory"

... I thought the "_it_" was referring to a "pointer" instead of plain "int". It didn't occur to me to that the actual article has extra text in between those 2 extracted quotes which drastically changes the assumption of what the pronoun "it" means. My mistake.

The Standard disagree.

C11 6.5.3.2p3 “The unary & operator yields the address of its operand. If the operand has type ‘type’, the result has type ‘pointer to type’.”

I understand the intention to warn about the abstraction C introduces, but you’ve confused things.

Pointers and addresses are perfectly covered.

What you really want to bring is what the Standard calls the “C abstract machine”, for which the memory model can be surprising.

> Pointers in C are a much higher level abstraction.

Not really; almost all programmers treat them as addresses and almost all compilers represent them that way. Regardless of what the standard actually says. Leading to surprises when this doesn't hold true, and awkwardnesses of the 16-bit x86 "near/far" pointers.

I mean, that's the only reason that "array[index]" and "index[array]" are interchangeable; you don't see that in other languages.

What higher level abstraction do pointers bring to the table over plain memory addresses other than pointer-arithmetic?

Reply on news.ycombinator.com