When you pass an arg variable into a function param by reference, check the const-ness of LHS vs RHS. This post is about when they differ const-wise. Note the most common and tricky situation is func pbref (ie pass-by-reference). A programmer needs to recognize them without thinking. The assignment operations below are less common but simpler.
Note — in pbref, on LHS we sometimes create a completely new ref (4-byte) with(out) const-ness. This ref has its (unknowable) new address. This address is different from address of the RHS (which must be a lval — u can’t do int& r = 4444).
I feel a const stackVar is a const object. There’s no other way to get at the object, since the const var blocks all  edits.
Q: Given f(const int & i), can you pass in an arg of non-const int variable?
A: yes. Const LHS is tolerant and extremely widespread. The pbref process adds constness to the new LHS reference. Equivalent to the simpler but less common
int arg = 9;
const int & a = arg;
Q: Remove const — Given f(int & i), can you pass in a const int variable?
A: illegal. The arg variable is const, so it promises not to modify state. The pbref process attempts to remove the constness. Equivalent to the simpler but less common
const int arg = 9;
int & a = arg; // illegal
In summary, Const-ness radiates from RHS to LHS. Illegal to block it.
* If RHS is a const ptr on the object, then that constness doesn’t radiate left-ward
* If RHS is a handle on a const object, then that constness radiates left-ward.
* If RHS is a handle on a mutable object, then LHS can be anything.
sound byte– if you have only a handle on a const object, then you can’t  modify its state even if you copy that handle. Object is not editable *via* this handle.
sound byte — If a method or a variable is declared without “const”, compiler assumes this “handle” (can and therefore) will modify object state.
Compiler disallows assigning a const RHS handle to a mutable LHS handle. “Handle” is typically a ref. (For a ptr, “const handle” means ptr-to-const). However, if you deep-copy a target object (not the 4-byte address), then const-ness doesn’t radiate left. You can make a mutable deep copy from a const object, without compromising const-ness of the RHS object. All subsequent “edits” happen on the deep copy.
Different context — Constness radiates rightward upon method-calling.
constObj.constMethod() // good
constObj.mutableMethod() // won’t compile
Q: need to explicitly remove constness of a q(const char *), which is a c-string
A: Yes. Constness radiates left. Use const_cast. See post on const char *
 copiers and assignments usually have const ref params.
 handle can mean a nonref variable or a ref/ptr
 except via explicit const_cast
(below is a piece of work in progress….)
Now we can better understand why auto_ptr is bad for containers. Given an auto_ptr object A. A’s copier and assignment both take a non-const RHS. Container functions need copier with const param ie a const LHS, but
* can they enforce that copier LHS be declared const? No. If you could then auto_ptr + container would have been illegal combination??
* can they enforce that copier RHS be declared const? No compiler can’t enforce it — const radiates left. Compiler can only enforce LHS to be const.