Question

A co-worker asked about some code like this that originally had templates in it.

I have removed the templates, but the core question remains: why does this compile OK?

#include <iostream>

class X
{
public:
     void foo() { std::cout << "Here\n"; }
};

typedef void (X::*XFUNC)() ;

class CX
{
public:
    explicit CX(X& t, XFUNC xF) : object(t), F(xF) {}      
    void execute() const { (object.*F)(); }
private:
    X& object;
    XFUNC F;
}; 

int main(int argc, char* argv[])
{   
    X x; 
    const CX cx(x,&X::foo);
    cx.execute();
    return 0;
}

Given that CX is a const object, and its member function execute is const, therefore inside CX::execute the this pointer is const.

But I am able to call a non-const member function through a member function pointer.

Are member function pointers a documented hole in the const-ness of the world?

What (presumably obvious to others) issue have we missed?

Answer 1

In this context object is a reference to a X, not a reference to a const X. The const qualifier would be applied to the member (i.e. the reference, but references can’t be const), not to the referenced object.

If you change your class definition to not using a reference:

// ...
private:
    X object;
// ...

you get the error you are expecting.