That should be good enough for ** and my understanding is that if you reach *** there's been a problem.
Three layers of indirection is excusable, and there are good reasons to even go higher, though increasing indirection causes increasing mental strain, so you should abstract as much of that away as possible if you need more.
Let's walk through this.
char* n is, for example, your typical string. The pointer goes to the first letter.
char** argv is, for example, your list of arguments. This means that, in memory, you have several consecutive pointers, each pointing at a null-terminated string. In practice, this ends up being a single hunk of memory, but you don't know that, and you probably shouldn't assume it, though assuming it can bring fun hacks.
char** is a lookup table.
Now, consider you're doing some argument parsing. You have a flag like "--nigger" that the argument syntax lets you put anywhere. So you handle it. But now you want to have an array of just the files, no flags. This is the job for a lookup table: char**. When you say "should be good enough for **" that's what most people mean: if you just want the strings, you can simply make a copy of the argv pointers and omit the pointers that point to things you don't want.
But wait, what if our opt parsing also can modify strings? What if it modifies the pointers in argv? What you need here is a pointer to a char**, a pointer to (a pointer to a pointer), so you're sure that you're actually pointing at the appropriate argv pointer. This calls for char***. You probably want to hide this in an auxiliary function or something to make it cleaner. But here's a basic sketch of a justification for arbitrary pointer nest depth. The deeper the depth, the less you'd expect to find justification, as this is contingent on specifically needing a pointer to the last level of nesting, and this requires a circumstance where duplicating a pointer at a lower nest depth isn't adequate.
It should be clear from this little illustration how much harder the justification for deeper nesting becomes as you deepen. But remember, code serves. If "bad code" serves, it isn't all that bad code.
