C++ pass-by-non-const-reference method inside pass-by-const-reference method

Question

I have this function pass_by_const(const std::string& s) which wants to call pass_by_non_const(std::string& s).

If I have this method's definition

pass_by_const(const std::string& s)
{
    pass_by_non_const(s);
}

would compiler yield at me, and are there work arounds ? I fear that pass_by_non_const modifies s behind my back.

Answer 1

What happens with

pass_by_const(const std::string& s)
{
    pass_by_non_const(s);
}

is: pass_by_const has const argument std::string s, so it is not allowed to modify the string s defined in enclosing scope and passed to him as an argument. However, pass_by_non_const is allowed to modify s. This raises compiler error at compile time.

A local non-const copy of s can be passed to pass_by_non_const however. Then, the local copy may be modified in the scope of pass_by_non_const, whereas the enclosing scope's s passed as an argument to pass_by_const is not altered.

Right way to write the method is then

pass_by_const(const std::string& s)
{
    std::string local_copy = s;
    pass_by_non_const(local_copy );
}

No more compile time error, local_copy may be modified in most inner scope, whereas s from enclosing scope won't be, which abide by the pass-by-const-ref-ness of the pass_by_const method.

Answer 2

You should not even want to call pass_by_non_const from pass_by_const because if an argument is a const reference you are "promising" to not modify it.

If you want to violate the type system (which is a bad thing), you could do ugly things like

 pass_by_const(const std::string& s)
 {
    pass_by_non_const(const_cast<std::string&>(s));
 }

But the point is that doing so is wrong, and could be undefined behavior. So anything bad could happen (a crash, or even the program accidentally doing what you want).

If you want to obey the type system and avoid violating invariants, make a local copy like suggested in antitrust's answer. Of course making a local copy might be costly.