const-correctness

问题 I've got a const method in my class, which cannot be changed to non-const. In this method, I need to call a non-const method but the compiler doesn't let me do that. Is there any way around it? Here is a simplified sample of my code: int SomeClass::someMethod() const { QColor saveColor = color(); setColor(QColor(255,255,255)); // Calling non-const method // .... setColor(saveColor); // restore color return 1; } 回答1: One of the challenges of doing const -correctness is you can't do it halfway.

问题 I recently had an exchange with another C++ developer about the following use of const : void Foo(const int bar); He felt that using const in this way was good practice. I argued that it does nothing for the caller of the function (since a copy of the argument was going to be passed, there is no additional guarantee of safety with regard to overwrite). In addition, doing this prevents the implementer of Foo from modifying their private copy of the argument. So, it both mandates and advertises

问题 As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance. Closed 6 years ago . I come from C background and am learning Python. The lack of explicit type-safety is disturbing, but I am getting used to it. The lack

问题 I know the answer is 99.99% no, but I figured it was worth a try, you never know. void SomeFunction(int a) { // Here some processing happens on a, for example: a *= 50; a %= 10; if(example()) a = 0; // From this point on I want to make "a" const; I don't want to allow // any code past this comment to modify it in any way. } I can do something somewhat similar with const int b = a; , but it's not really the same and it creates a lot of confusion. A C++0x-only solution is acceptable. EDIT :

问题 I have a function that receives float** as an argument, and I tried to change it to take const float** . The compiler ( g++ ) didn't like it and issued : invalid conversion from ‘float**’ to ‘const float**’ this makes no sense to me, I know (and verified) that I can pass char* to a function that takes const char* , so why not with const float** ? 回答1: See Why am I getting an error converting a Foo** → const Foo**? Because converting Foo** → const Foo** would be invalid and dangerous ... The

问题 I have a container class which uses boost::optional to hold the value. Here is the code looks like, template<typename T> struct traits { typedef T value_type; typedef T& reference; }; template<typename T> struct traits<const T> { typedef const T value_type; typedef const T& reference; }; template<typename T> struct traits<T*> { typedef T* value_type; typedef T* reference; }; template<typename T> struct traits<const T*> { typedef const T* value_type; typedef const T* reference; }; template

问题 I am creating a constructor that will take a pair of input iterators. I want the method signature to have compile-time const semantics similar to: DataObject::DataObject(const char *begin, const char *end) However, I can't find any examples of this. For example, my STL implementation's range constructor for vector is defined as: template<class InputIterator> vector::vector(InputIterator first, InputIterator last) { construct(first, last, iterator_category(first)); } which has no compile-time

问题 There are many questions discussing the details of C and C++ dealing with pointer-to-const deletion, namely that free() does not accept them and that delete and delete[] do and that constness doesn't prevent object destruction. What I am interested on is whether you think it is a good practice to do so, not what the languages (C and C++) allow. Arguments for pointer-to-const deletion include: Linus Torvalds' kfree() , unlike C's free() , takes a void const* argument because he thinks that

问题 I was merily experimenting with the new trailing return types, where I hit a problem with this (simplified) code #include <list> class MyContainer{ std::list<int> ints; auto begin( ) -> decltype(ints.begin()) { return ints.begin(); } auto begin( ) const -> decltype(ints.begin()) { return ints.begin(); } }; Ignore the fact of how pointless this code is. The important part is the compiler error generated when using GCC 4.6.1 (with -std=c++0x flag): In member function 'std::list<int>::iterator

问题 Suppose I have class A final { int& ir; public: A(int& x) : ir(x) { } void set(int y) { ir = y; } // non-const method! int get() const { return ir; } }; and const int i; Obviously I can't have A a(i); since that would breaks constness. But I also cannot have const A a(i); despite the fact that this will not break constness de-facto. C++ doesn't support "const-only" ctors, e.g. in this case one which would take a const int& . Is there a way to get const A a wrapping a reference to i - other