Question: What does `const` at "top level" qualifier mean in C++?

And what are other levels?

For example:

```
int const *i;
int *const i;
int const *const i;

```

Answer: 
A top-level const qualifier affects the object itself. Others are only
relevant with pointers and references. They do not make the object
const, and only prevent modification through a path using the pointer or
reference. Thus:

```
char x;
char const* p = &x;

```

This is not a top-level const, and none of the objects are immutable.
The expression `*p` cannot be used to modify `x`, but other expressions
can be; `x` is not const. For that matter

```
*const_cast<char*>( p ) = 't'

```

is legal and well defined.

But

```
char const x = 't';
char const* p = &x;

```

This time, there is a top-level const on `x`, so `x` is immutable. No
expression is allowed to change it (even if `const_cast` is used). The
compiler may put `x` in read-only memory, and it may assume that the
value of `x` never changes, regardless of what other code may do.

To give the pointer top-level `const`, you'd write:

```
char x = 't';
char *const p = &x;

```

In this case, `p` will point to `x` forever; any attempt to change this 
is undefined behavior (and the compiler may put `p` in read-only memory,
or assume that `*p` refers to `x`, regardless of any other code).
The two levels of const are:
\* Low-level Const
\* Top-level Const

You should look at top and low level const through references and pointers, because this is where they are relevant.

```
int i = 0;
int *p = &i;
int *const cp = &i;
const int *pc = &i;
const int *const cpc = &i;

```

In the code above, there are 4 different pointer declarations. Let's go through each of these,

`int *p`: **Normal Pointer** can be used for making changes to the underlying object and can be reassigned.

`int *const cp` (top-level const): **Const Pointer** can be used for making changes to the underlying object but cannot be reassigned. (Cannot change it to point to another object.)

`const int *pc` (low-level const): **Pointer to Const** cannot be used for making changes to the underlying object but can itself be reassigned.

`const int *const cpc` (both top and low-level const): **Const Pointer to a Const** can neither be used for making changes to the underlying object nor can itself be reassigned.

Also, top-level const is always ignored when assigned to another object, whereas low-level const isn't ignored.

```
int i = 0;
const int *pc = &i;
int *const cp = &i;

int *p1 = cp; // allowed
int *p2 = pc; // error, pc has type const int*

```

Hope this helped :)
FYI: C++ Primer has a lot of information about the same!!!