No problem. A pointer to any data element always has the same size. So a pointer to an `int` (`int *`) has the same size as a pointer to a `char` (`char *`) or even a pointer to a `pointer to a char` (`char **`). On 99% of all architectures a pointer to **anything** will have the same size (it is technically possible for an architecture to make a difference between a pointer to data and a pointer a function, i.e. executable code). 

While there's many reasons why a pointer to a pointer makes heads spin (try triple pointers, ugh), the size should be pretty straightforward :).

But, it always helps to think about what we are allocating here. `ycurrent->yarray` is an array of strings. Strings in C are usually char arrays or pointers. So that makes it an array of (an array of chars). The amount of strings in the in the array is `yanklines`, and the size of each element is `sizeof(char_u *)`. To put it in another way:

```c
/* pseudo-code and execution, haven't checked */
sizeof(y_current->y_array) == sizeof(char_u **) /* == 8 (on most 64-bits systems) */
sizeof(y_current->y_array[0]) == sizeof(*(y_current->y_array[0])) == sizeof(char_u *) /* ==  8 (on most 64-bits systems) */
```

From this it's clear that semantically, we'd need to substitute the second line. As we are allocating `yanklines` elements in the array `char **y_array`, and each element has `sizeof(char_u *)`.

You might wonder: how is something like `sizeof(y_current->y_array[0])` or equivalently `sizeof(*(y_current->y_array[0]))` even possible? We haven't even allocated yet, this should cause a NULL pointer error in the best case!

But that's the peculiar behaviour of the `sizeof` operator, it doesn't evaluate its parameter. The compiler just calculates what the size of the resulting value would be, if it *were* evaluated.

Now, this kind of thing can be pretty confusing, even for old-timers reading the code. I myself find that in this case, it's clearer to just use `sizeof(char_u *)`. Moral of the story: be judicious, if the variable is simple, use `sizeof(variable)`, if the variable is complex, use `sizeof(the_actual_type)`. This is a case of the latter.

So the actual line should become:

```c
/* void *xcalloc(size_t num, size_t size); */
y_current->y_array = xcalloc(yanklines, sizeof(char_u *));
```

Nice and simple :).