Thread: differences between const applications

Consider this class:

Code:

class X
{
public:
    int get()
    {
        return value;
    }

    void set(int n)
    {
        value = n;
    }
private:
    int value = 0;
};

Now, suppose you declare an object of this class and use it:

Code:

X x;
x.set(123);
std::cout << x.get() << std::endl;

No problem, great. But what if we have a function like this:

Code:

void foo(const X& x)
{
    x.set(123);
    std::cout << x.get() << std::endl;
}

That we call like this:

Code:

X x;
foo(x);

Now, the compiler will complain, informing us that in the context of foo, x, being a const reference, cannot be modified. Okay, so we modify it before we call the function:

Code:

void foo(const X& x)
{
    std::cout << x.get() << std::endl;
}

and:

Code:

X x;
x.set(123);
foo(x);

But the compiler still complains that we're trying to modify x in a const context! The reason is that get, despite not modifying the member variable named value, remains a non-const member function, and so it could plausibly be changed to modify a member variable of the X object. Therefore, we should write:

Code:

class X
{
public:
    int get() const
    {
        return value;
    }

    void set(int n)
    {
        value = n;
    }
private:
    int value = 0;
};

If you're comfortable with the relationship between pointers and const, and which pointer conversions are allowed, then you can apply that understanding to const member functions.

Imagine that each member function is a free function that takes a pointer to the object instance as a first parameter, this:

Code:

    struct Point2D {
        double x;
        double y;

        double r() const;
        void reflectOverYAxis();
    };

    // real C++
    double Point2D::r() const {
        return std::sqrt(x * x  +  y * y);
    }

    // also real C++
    double Point2D::r() const {
        return std::sqrt(this->x * this->x  +  this->y * this->y);
    }

    // still real C++
    double Point2D::r() const {
        const Point2D* instance = this;
        return std::sqrt(instance->x * instance->x  +  instance->y * instance->y);
    }

    // still real C++, but no longer a member function
    double r(const Point2D* instance) {
        return std::sqrt(instance->x * instance->x  +  instance->y * instance->y);
    }

Compare that with an implementation of reflectOverYAxis, which being a non-const member function, would have a this pointer of type Point2D* instead of const Point2D*:

Code:

    // real C++
    void Point2D::reflectOverYAxis() {
        x *= -1;
    }

    // also real C++
    void Point2D::reflectOverYAxis() {
        this->x *= -1;
    }

    // still real C++
    void Point2D::reflectOverYAxis() {
        Point2D* instance = this;
        instance->x *= -1;
    }

    // still real C++, but no longer a member function
    void reflectOverYAxis(Point2D* instance) {
        instance->x *= -1;
    }

The difference is that in a const member function, this points to a const instance, while in a non-const member function this points to a non-const instance. You can't modify the members of a const instance (or any const aggregate object), so the result is that const member functions don't let you change data members.

To laserlight's point, even if a non-const member function does not modify instance data, you still can't call that member function on a const instance, because you can't cast a const T* to a T*. It would be like trying to call the last version of reflectOverYAxis with a const Point2D*.