Question

I’m having some trouble with a particular piece of code, if anyone can enlighten me on this matter it would be greatly appreciated, I’ve isolated the problem down in the following sample:

#include <iostream>  using namespace std;  class testing{    int test();    int test1(const testing& test2); };  int testing::test(){    return 1; }  int testing::test1(const testing& test2){    test2.test();    return 1; } 

So what could possibly have cause the following error:

test.cpp:15: error: passing ‘const testing’ as ‘this’ argument of ‘int testing::test()’ discards qualifiers

Thanks a lot!

Answer 1

The problem is calling a non-const function test2.test() on a const object test2 from testing::test1.

testing::test1 gets test2 as a parameter const testing &test2. So within testing::test1, test2const. Then in the first line of the function:

test2.test() 

The testing::test function is called on test2. That function is not declared with const at the signature end, so it may modify the object it is called on (the this pointer implicitly passed to it), and even though it does not, the compiler assumes so. By letting you call it there, the compiler would let you modify a const variable without an explicit cast, which C++ is not supposed to allow. Therefore to explain the error message:

test.cpp:15: error: passing ‘const testing’ as ‘this’ argument of ‘int testing::test()’ discards qualifiers 

this refers to the object the member function (testing::test) operates on, and in this case it is not const, because testing::test was not declared with const, and thus the mismatch is detected when trying to make a non-const pointer (this) refer to a const object (testing), ignoring the const qualifier.

To solve this, decide whether the testing::test function should ever need to modify the object it is called on (the way it is written now it does not, as all it does is return 1, however that may change, so you need to think at what its intended functionality is). If it should, then obviously calling it on a const object is bad, although you can use const_cast to ask the compiler to override that, but this is dangerous. If it should not, then mark it const, so that it can be called on const objects as well:

class testing{     int test1() const;     // ... }  int testing::test() const {     // ... }