Can someone explain pointers to pointers to me

Question

We recently talked in college about pointers to pointers (e.g: char **ppch) and from my understanding they can be used as 2D arrays since a char *pch, for example, can be used as an array of char/string.

Is that the case or did I miss something? I'm not sure on how we work with P2P in a program or if my understanding is even close to correct.

Can someone provide an example? Do we need to allocate memory with malloc() for each element in these P2Ps?

@TomKuschel Although an array of arrays is not the same as a pointer to pointer. — Some programmer dude, Dec 01 '18 at 17:30
Pointer to pointers can indeed be used for [jagged arrays](https://en.wikipedia.org/wiki/Jagged_array). It can also be used to emulate pass-by-reference for a pointer variable. — Some programmer dude, Dec 01 '18 at 17:35
@Someprogrammerdude that seems logical. I'll try writing a small `P2P` program and posting it here for review. — Stelios Papamichail, Dec 01 '18 at 17:38
Maybe this link helps too: [how do pointer to pointer work in c](https://stackoverflow.com/questions/897366/how-do-pointer-to-pointers-work-in-c) — Tom Kuschel, Dec 01 '18 at 17:45

Swordfish · Accepted Answer · 2018-12-02T07:17:09.117

An inherent property of arrays is, that their elements are consecutive in memory. Eg.

int foo[] = { 1, 2, 3, 4, 5, /* ... */ };
// ~> 1, 2, 3, 4, 5, ...

A 2d array is no different:

int bar[][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
// ~> 1, 2, 3, 4, 5, 6, 7, 8, 9

But a pointer to a pointer of some type

int **qux;

is just that. A pointer to a pointer (or a number of pointers). When you allocate memory like

int **qux = malloc(N * sizeof(*qux));

you get a pointer to a region of memory large enough to hold N pointers to int which in turn can point to other regions of memory:

int **qux = malloc(N * sizeof(*qux));
int value = 0;
for (size_t i = 0; i < N; ++i) {
    qux[i] = malloc(P * sizeof(**qux));
    for (size_t k = 0; k < P; ++k)
        qux[i][k] = ++value;
}

That looks in memory like

+----------+                              +-----+
| qux[0] --|------------------------------|-> 1 |
| qux[1] --|-----------+                  |   2 |
| qux[2] --|---+       |       +-----+    |   3 |
| ...      |   |       +-------|-> 4 |    +-----+   
+----------+   |               |   5 |       
               |    +-----+    |   6 |
               +----|-> 7 |    +-----+
                    |   8 |
                    |   9 |
                    +-----+

So no, a pointer to a pointer is not a 2d-array. Things like that are rather called "jagged array".

As for your example with strings, there is no difference:

char **qux;  // a pointer to a (number of) pointers to char

qux = malloc(N * sizeof(*foo));

// just an array to fill the memory qux points to with:
char const *source[] = { "foo", "bar", "baz", "qux" /* I'm running out of names */ };
size_t index = 0;

for (size_t i = 0; i < N; ++i) {
    qux[i] = malloc((strlen(source[index]) + 1) * sizeof(**qux));
    strcpy(qux[i], source[index++]);
}

~>

+----------+                                                      +--------+
| foo[0] --|------------------------------------------------------|-> 'f'  |
| foo[1] --|-----------------------------------+                  |   'o'  |
| foo[2] --|----------------------+            |    +--------+    |   'o'  |
| foo[3] --|---+                  |            +----|-> 'b'  |    |   '\0' |   
| ...      |   |                  |                 |   'a'  |    +--------+   
+----------+   |    +--------+    |   +--------+    |   'r'  |
               +----|-> 'q'  |    +---|-> 'b'  |    |   '\0' |
                    |   'u'  |        |   'a'  |    +--------+
                    |   'x'  |        |   'z'  |
                    |   '\0' |        |   '\0' |
                    +--------+        +--------+

In contrast a real 2d-array of chars:

char foo[][4] = { "foo", "bar", "baz", "qux" /*, ... */ };
// ~> 'f', 'o', 'o', '\0', 'b', 'a', 'r', '\0', 'b', 'a', 'z', '\0', 'q', 'u', 'x', '\0', ...

Possibly part of OP's confusion is because they use a `char *`-vs.-string as an example. In that case, a pointer to a list of char strings *might* be considered 2D (where the elements are separate characters). Perhaps the OP would like to comment on your answer? — Jongware, Dec 01 '18 at 17:47
@Swordfish before i ask some questions regarding your very helpful answer, i got a quick question. In `qux[i] = malloc(P * sizeof(**qux));` shouldn't that be `..sizeof(*qux)` — Stelios Papamichail, Dec 01 '18 at 17:50
@SteliosPapamichail The type of `qux` is `char**`. The type of `*qux` is `char*`. The type of `**qux` is `char`. — Swordfish, Dec 01 '18 at 18:00
@Swordfish i will, but i need some time to understand everything. I'm having a hard time with pointers in general so i have to read your answer many times over till i get it through my head. — Stelios Papamichail, Dec 01 '18 at 18:24
@SteliosPapamichail If you have any further question please feel free to ask away. — Swordfish, Dec 01 '18 at 18:26
@Swordfish thank you very much, will do! Just need some more time ;) ! — Stelios Papamichail, Dec 01 '18 at 18:28
@Swordfish btw in the last example of string ** shouldn't it be foo instead of qux :P — Stelios Papamichail, Dec 01 '18 at 18:30
@SteliosPapamichail `foo`, `qux`, `wtfijr`*) ... take the one you like (*: what the ... heck, it's just random) — Swordfish, Dec 01 '18 at 18:54
@DavidBowling That looks great! You still can become the next DaVinci! — Swordfish, Dec 01 '18 at 19:30

Can someone explain pointers to pointers to me

1 Answers1