In C++20, you can just return a std::span with elements of type const int* #include <vector> #include <span> class Data { public: std::span<const int* const> getIndex() const { return this->index; } private: std::vector<int*> index; }; int main() { const Data data; const auto index = data.getIndex(); *index[0] = 5; // error: assignment of read-only location … Read more
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
Const correctness provides two notable advantages to C++ that I can think of, one of which makes it rather unique. It allows pervasive notions of mutable/immutable data without requiring a bunch of interfaces. Individual methods can be annotated as to whether or not they can be run on const objects, and the compiler enforces this. … 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
From the standard: const char c=”c”; char* pc; const char** pcc = &pc; // not allowed *pcc = &c; *pc=”C”; // would allow to modify a const object
I’ll answer in reverse order so to begin with the simple cases. Utility functions that accept objects from the factory functions, use them, but do not take ownership. (For example a function that counts the number of words in the document.) If you are calling a factory function, you are always taking ownership of the … 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
I’d probably write a tiny wrapper class for each: template <class T> class read_only { T volatile *addr; public: read_only(int address) : addr((T *)address) {} operator T() volatile const { return *addr; } }; template <class T> class write_only { T volatile *addr; public: write_only(int address) : addr ((T *)address) {} // chaining not allowed … 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 had this same problem a few years ago and it irked me to no end. The rules in C are more simply stated (i.e. they don’t list exceptions like converting char** to const char*const*). Consequenlty, it’s just not allowed. With the C++ standard, they included more rules to allow cases like this. In the … Read more