The way you proposed is perfectly fine, except if in your code you need to make assignment of RockSolid variables, like this: RockSolid a(0,1); RockSolid b(0,1); a = b; This would not work as the copy assignment operator would have been deleted by the compiler. So an alternative is to rewrite your struct as a … Read more
One solution would be to factor all of the mutation code into a lambda expression. Do all of the mutation in the lambda expression and assign the result out to a const int in the method scope. For example void SomeFunction(const int p1) { auto calcA = [&]() { int a = p1; a *= … Read more
It’s quite simple. Say I have a vector: std::vector<int> vec; I fill it with some data. Then I want to get some iterators to it. Maybe pass them around. Maybe to std::for_each: std::for_each(vec.begin(), vec.end(), SomeFunctor()); In C++03, SomeFunctor was free to be able to modify the parameter it gets. Sure, SomeFunctor could take its parameter … Read more
This is the definitive article on “const correctness”: https://isocpp.org/wiki/faq/const-correctness. In a nutshell, using const is good practice because… It protects you from accidentally changing variables that aren’t intended be changed, It protects you from making accidental variable assignments. For instance, you are protected from if( x = y ) // whoops, meant if( x == … Read more
C and Python belongs to two different classes of languages. The former one is statically typed. The latter is dynamic. In a statically typed language, the type checker is able to infer the type of each expression and check if this match the given declaration during the “compilation” phase. In a dynamically typed language, the … Read more
const correctness can’t improve performance because const_cast and mutable are in the language, and allow code to conformingly break the rules. This gets even worse in C++11, where your const data may e.g. be a pointer to a std::atomic, meaning the compiler has to respect changes made by other threads. That said, it is trivial … Read more
See Why am I getting an error converting a Foo** → const Foo**? Because converting Foo** → const Foo** would be invalid and dangerous … The reason the conversion from Foo** → const Foo** is dangerous is that it would let you silently and accidentally modify a const Foo object without a cast The reference … Read more
Basically, there’s a slight language problem here. std::string func() { return “hai”; } func().push_back(‘c’); // Perfectly valid, yet non-sensical Returning const rvalues is an attempt to prevent such behaviour. However, in reality, it does way more harm than good, because now that rvalue references are here, you’re just going to prevent move semantics, which sucks, … Read more
I’ve come across this issue a lot of times too and ended up using interfaces. I think it’s important to drop the idea that C# is any form, or even an evolution of C++. They’re two different languages that share almost the same syntax. I usually express ‘const correctness’ in C# by defining a read-only … Read more
There is no way to do it except for the cast. This is significant drawback of the idea to pass arrays in this way. Here is a similar thread where the C rules are compared to the C++ rules. We could conclude from this comparison that the C rules are not so well designed, because … Read more