const-cast

It is known that std::array::operator[] since C++14 is constexpr , see declaration below: constexpr const_reference operator[]( size_type pos ) const; However, it is also const qualified. This causes implications if you want to use the subscript operator of a std::array in order to assign values to your array at compile time. For example consider the following user literal: template<typename T, int N> struct FooLiteral { std::array<T, N> arr; constexpr FooLiteral() : arr {} { for(int i(0); i < N; ++i) arr[i] = T{42 + i}; } }; The above code won't compile if you try to declare a constexpr

I was wondering whether the following is undefined behavior // Case 1: int *p = 0; int const *q = *const_cast<int const* const*>(&p); // Case 2: (I think this is the same) int *p = 0; int const *const *pp = &p; int const *q = *pp; Is this undefined behavior by reading a int* as if it were a int const* ? I think it is undefined behavior, but I previously thought that only adding const in general is safe, so I'm unsure. Qualification-wise, it's fine. With each expression split into a statement: int *p = 0; // ok int **addrp = &p; // ok int const *const *caddrq = addrp; // ok, qualification conv.

Does the following program have undefined behavior? #include <iostream> #include <vector> struct Foo { const std::vector<int> x; }; int main() { std::vector<int> v = {1,2,3}; auto f = new Foo{v}; const_cast<int&>(f->x[1]) = 42; // Legal? std::cout << f->x[1] << "\n"; } Note that it not using const_cast to strip constness from f->x , but instead stripping constness from f->x[x] , which presumably is represented by a separate array. Or is a translation allowed to presume that f->x[1] is immutable after it is created? There is no Undefined Behavior in your example. The above code does not invoke

As per Scott Meyers, to prevent repetition of code in the const version of a getter and the non-const version of a getter, call the const version of the method from the non-const version: static_cast<const A&>(*this).Methodology(); however , in accidental usage due to an overzealous Visual Assist X Intellisense I typed: const_cast<const A&>(*this).Methodology(); and it worked just fine. What are any and all differences in this case with using a particular cast? IDE in use: Visual Studio 2010. Attila Assuming that the type of this is A* , there is no difference. In general const_cast can cast

If I do: const char* const_str = "Some string"; char* str = const_cast<char*>(const_str); // (1) str[0] = "P"; // (2) Where (which line) exactly is the undefined behavior ? I've been searching a lot for this on SO but haven't found any explicit and precise answer (or at least, none that I could understand). Also related: if I use an external library which provides this kind of function: // The documentation states that str will never be modified, just read. void read_string(char* str); Is it ok to write something like: std::string str = "My string"; read_string(const_cast<char*>(str.c_str()));

Is there any good way to obviate the const_cast below, while keeping const correctness? Without const_cast the code below doesn't compile. set::find gets a const reference to the set's key type, so in our case it guarantees not to change the passed-in pointer value; however, nothing it guaranteed about not changing what the pointer points to. class C { public: std::set<int*> m_set; bool isPtrInSet(const int* ptr) const { return m_set.find(const_cast<int*>(ptr)) != m_set.end(); } }; Arvid Yes . In C++14, you can use your own comparator that declares int const* as transparent . This would enable