const-correctness

Recently I found a piece of C++ code that effectively does the following: char* pointer = ...; const char* constPointer = const_cast<const char*>( pointer ); Obviously the author thought that const_cast means "add const", but in fact const can be just as well added implicitly: const char* constPointer = pointer; Is there any case when I would really have to const_cast to a pointer-to-const ( const_cast<const Type*> as in above example)? const_cast , despite its name, is not specific to const ; it works with cv-qualifiers which effectively comprises both const and volatile . While adding such a

I understand that having a const method in C++ means that an object is read-only through that method, but that it may still change otherwise. However, this code apparently changes an object through a const reference (i.e. through a const method). Is this code legal in C++? If so: Is it breaking the const -ness of the type system? Why/why not? If not: Why not? Note 1: I have edited the example a bit, so answers might be referring to older examples. Edit 2: Apparently you don't even need C++11, so I removed that dependency. #include <iostream> using namespace std; struct DoBadThings { int *p;

About six years ago, a software engineer named Harri Porten wrote this article , asking the question, "When should a member function have a const qualifier and when shouldn't it?" I found it to be the best write-up I could find of the issue, which I've been wrestling with more recently and which I think is not well covered in most discussions I've found on const correctness. Since a software information-sharing site as powerful as SO didn't exist back then, I'd like to resurrect the question here. The article seems to cover a lot of basic ground, but the author still has a question about const

In defining a function in an interface : virtual void ModifyPreComputedCoeffs ( std::vector < IndexCoeffPair_t > & model_ ) = 0; we want to specify that the vector model_ should not be altered in the sense push_back etc operations should not be done on the vector, but the IndexCoeffPair_t struct objects in the model_ could be changed. How should we specify that ? virtual void ModifyPreComputedCoeffs ( const std::vector < IndexCoeffPair_t > & model_ ) = 0; does not work I think. The C++ const-correctness concept is IMO way overrated. What you just discovered is one of the big limitations it has

Consider the following: class A { public: const int c; // must not be modified! A(int _c) : c(_c) { // Nothing here } A(const A& copy) : c(copy.c) { // Nothing here } }; int main(int argc, char *argv[]) { A foo(1337); vector<A> vec; vec.push_back(foo); // <-- compile error! return 0; } Obviously, the copy constructor is not enough. What am I missing? EDIT: Ofc. I cannot change this->c in operator=() method, so I don't see how operator=() would be used (although required by std::vector). I'm not sure why nobody said it, but the correct answer is to drop the const , or store A* 's in the vector

I'm writing software for an embedded system. We are using pointers to access registers of an FPGA device. Some of the registers are read-only, while others are write-only. The write-only registers will produce undefined values when read. I want to define a pointer type that will allow the compiler to detect when reading values from a write-only registers (a.k.a. dereferencing). Can a write-only pointer be created using only C language syntax? (We are developing first prototype using C, but moving to C++ on 2nd generation.) How can an efficient write-only pointer be created in C++? (Remember,