C++ - Using a template to return a const reference publicly and a non const reference privately

Question

The question: How can I make it so that a const reference is returned publicly and a non const reference returned privately?

I'm trying to create a read-only template for some variables in my classes. This involves a template class which returns a const reference to the data when public. However in the class I need to operate on the data so I am trying to return a reference that is not const privately. Here's the basics:

private: operator T&() { return data; }
public: operator const T&() const { return data; }

When I add the non const reference as shown above, if I try to access the variable publicly my Visual Studio 2010 cl.exe compiler tells me it cannot access the private member in the class. Something as simple as cout << myobj.x << endl if x was declared using the template will fail.

error C2248: 'proxy<T,C>::operator int &' : cannot access private member declared in class 'proxy<T,C>'

Here is the other thread for reference:
C++ - How to make read only class member variables in Visual Studio 2010 - Stack Overflow

Edit: You asked for the code so here it is.

template <class T, class C>
class proxy {
    friend C;
private:
    T data;
    T operator=(const T& arg) { data = arg; return data; }
    operator T&() { return data; } // I'd expect this is only returned privately
public:
    operator const T&() const { return data; }
};

class myClass {
public:
    proxy<int,myClass> x;

    void f(int i) {
        x = i;
    }
};

int main(int argc, char **argv)
{
    myClass test;
    test.f(12);
    cout << test.x << endl; // Compiler error trying to access non-const T&
    return 0;
}

Answer 1

Actually, visibility and accesibility are independent things in C++:

• Visibility rules say that all the member functions are considered when resolving an overload.
• Accesibility means that if the chosen overload function is not accesible from the used context (private member from outside of the class, for example) a compiler error will happen.

Some people think that private members will not participate in overload resolution if the function in called from outside of the class, but that's not the case. All functions, irrespective of the access, are considered.

About your specific problem, you do:

std::cout << test.x;

Here test is non-const, so is test.x, and of the two overload conversion functions, the non-const one is chosen. But, alas, this function is private, thus compiler error.

The quick solution is to do a const_cast:

std::cout << const_cast<const myClass&>(test).x;

Or if you prefer:

const myClass &ctest = test;
std::cout << ctest.x;

The right solution would be to just remove the non-const private one. You don't need it, since from the class context you can use the data member directly.

Frankly, it looks like you are trying to implement properties in C++ using the syntax from other languages. Properties are fine, but that's not the C++ way.

My advice is: do not fight the language, accept the syntax as it is, and just do the parenthesis thing. Or if x does not hold an invariant, just do it public.

The shortest way would be something like:

class myClass {
private:
    int _x;
public:
    int x() const {
        return _x;
    }
    //if needed
    void x(int value) {
        _x = value;
    }
};

The people that will read your code in the future (mind you, it might be me!) will greatly appreciate that you do not try and reinvent the language.

Answer 2

In C++, access checks are done after overload resolution. This has both advantages and disadvantages over the other possibility -- removing inaccessible functions from the candidate set.

Usually the solution is to use a different name for the private function. But it appears that you're trying to conform to a particular interface required by some functions you've befriended. I don't think there's an easy workaround for that. Private inheritance won't help in the general case, because inherited functions aren't part of the candidate set, they're hidden by a function in the derived class. But conversion functions are inherited... and after testing, it seems that the original problem recurs (even a private conversion in a private base class is found).

So I finally suggest using a named function instead of a conversion, as in:

template <typename T, typename C>
class proxy
{
    friend C;
private:
    T data;
    T operator=(const T& arg) { data = arg; return data; }
    T& mutate() { return data; }
public:
    operator const T&() const { return data; }
};

class myClass
{
public:
    proxy<int,myClass> x;

    void f(int i)
    {
        x.mutate() = i;
    }
};

Answer 3

test is not const, test.x is not const, so myClass::operator int() is a better match that myClass::operator int() const.

Access control (private/public) doesn't enter into it.