将对象复制到另一个对象时，为什么 C++ 需要对两个对象进行低级 const 限定？

Question

I was reading C++-Primer (by Josée Lajoie and Stanley B. Lippman) when I came across this section about top-level and low-level const s. On one paragraph, it says that when copying an object, top level const s are ignored.

Eg.

const int i = 24;
int i2 = i;

Where the top-level const qualification in i is ignored when copied into i2 .

However, it also states

On the other hand, low-level const is never ignored. When we copy an object, both objects must have the same low-level const qualification or there must be a conversion between the types of the two objects. In general, we can convert a non const to const but not the other way around.

Now, usually when C++ has a rule like this there's a reason behind them. I find that understanding them is fundamental to understanding the rule and therefore making it easier to memorize (this is like understanding a mathematic concept instead of memorizing formulas). However, there's no logical rule I find that fits into the puzzle here.

As a summary, my question is:

1. Why is that when copying an object the top-level const qualification is ignored? (There's a section explaining why in the book too, but I can't seem to get it)

Copying and object doesn't change the copied object. As a result, it is immaterial whether the object copied from or copied into is const

2. What's the reason behind how low-level const is never ignored when copying an object? (low-level const qualification is needed on both objects)

Answer 1

Top level case: You make a copy of the const object, so it doesn't matter if your copy is const or not, because (assuming const-correct types) you can't modify the original via the copy.

Low level case: You make a copy of a handle to another object. The original handle does not allow modification of the object it refers to. Allowing to ignore the low level const would mean you can obtain a handle that allows you to modify the referred object, breaking const correctness.

It would allow this kind of craziness:

// should not modify n, right?
void foo(const int& n)
{
    int& mutable_n = n;
    mutable_n = 42;
}

...

int n = 0;
foo(n); // should not modify n, right?
std::cout << n << '\n'; // prints 42, wat??