
Everything you need to know about pointers in C (2010) - ank_the_elder
https://boredzo.org/pointers/
======
slmjkdbtl
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](http://c-faq.com/decl/charstarws.html)

[1] [https://adium.im/](https://adium.im/)

~~~
sai_c
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.

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

~~~
sai_c
Sorry, will do so in the future. Thx.

------
jwilk
> 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...](https://stackoverflow.com/questions/3523145/pointer-arithmetic-
for-void-pointer-in-c#3524270)

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

~~~
jwilk
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".

------
weltensturm
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.

~~~
MaxBarraclough
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](https://dlang.org/spec/declaration.html#declaration_syntax)

------
0x6862
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...](https://github.com/Droogans/unmaintainable-code#cs-eccentric-
view-of-arrays)

------
ChrisSD
> 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.

~~~
jasode
_> 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;
      }

~~~
unwind
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;
        }

~~~
MaxBarraclough
There's a double-quote character missing.

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

