How to distinguish different pointer's meaning?

Question

Pointers are useful for so many things, that it is sometimes impossible to understand what they mean in a particular line of code.
For exemple sometimes you use pointers to represent a succession of elements:

char* char_array = "abcd";
int* int_array = malloc(5 * sizeof(*int_array));

And sometimes you use pointers to allocate a single object on the heap or to make one element to points to another:

int a = 5;
int* int_ptr = &a;
struct item* an_item = malloc(sizeof(*an_item));

When both use collides, successive pointers become unreadable:

    struct cell** board;
 // Does this represent a succession of cell allocated on the heap,
 // a succession of pointers to uniques cells (like an array),
 // a succession of pointers to multiples cells (like a two dimensional array)?

 // Of course the more you add pointers the more it becomes confusing.
    struct cell*** board;

I thinked about using typedef or macros to make a type that represent a pointer used as a reference or as something that have been malloc-ed.
This could be double-edged because in some cases I will gain readability, but it will also obfuscate the code.
What do you recommend to produce code where the meaning of pointers is easier to understand?

Answer 1

Meaning of pointer is always the same. It is always actually pointing at a single object only. Therefore, A pointer is a variable pointing to a single place in memory

---

As for your different examples

When you do something like

char* char_array = "abcd";
int* int_array = malloc(5 * sizeof(*int_array));

In this also, the pointer char_array is pointing to the single char, which is a of the whole string "abcd". It so happens, that due to the way it is initialized (string literal), there are characters stored in the next memory locations.

---

The pointer in the above example is actually the same as char_ptr below

char* char_array = "abcd";
char* char_ptr = char_array;

If you you it like this

printf(" %c", char_ptr);

It will print a

If you do something like

printf(" %s", char_ptr);

It will print the whole string "abcd"

Here you can see that char_ptr also is acting how char_array would have in a printf() statement,

Answer 2

What do you recommend to produce code where the meaning of pointers is easier to understand?

It is indeed true that the meaning of pointers can be unclear to an outsider of the code. I recommend prefixing the variable names to give them more meaning.

See: https://en.wikipedia.org/wiki/Hungarian_notation#Examples

Of course you don't have to follow this example in detail. You can find multiple way's to prefix or make up your own. As long as you explain it somewhere you should be good.

Answer 3

This is a lot about code style, so there could be different answers and they all can be right, but presenting a different style - or point of view - if you will.

My advice would be to never go beyond two *. And if I remember well my C coding, I used two * only for void ** type.

In all other cases, use typedef (not macros!) and make a good structure of your objects.

With typedef, create name for each level. So, if you start with a type CELL, and you want array of these, call it e.g. CELL_LIST, which would be an array of (a pointer to) CELLs. You want array of CELL_LIST? Name it BOARD for example.

So CELL_LIST is pointer to CELL. BOARD is pointer to CELL_LIST (could be named ROW too). Need another dimension? Call it BOARD_LIST or BOARD_3D ...