c++ nonconst-const-overloaded method choosing - c++

Question

I have const-overloaded methods in my class:
class A{
public:
typedef int data[10];
data& operator[](int index);
const data& operator[](int index) const;
}
This class is implementing copy-on-write for its internal data. I figured that since i am allowing to access data directly, i must create copy of shared data (if it is shared obviously) on every use of operator[], but not operator[] const. However, even if code is using operator[] for reading data, but object itself is not declared as const, it will still cause creating copy, as operator[] will be used. Is there any syntax that would let me allow to choose which of those operators i am calling?

Answer 1

Yes: const_cast<A const&>(anAObj)[5].

Answer 2

Why does the operator return a data& rather than an int& that references a single item?
That being said your options include:
Always do the copy even if it turns out to be unneeded.
Use the operator for read or write, and a named method (GetRef for example) for the other one.
Cast the object to const at the use point: static_cast<const A&>(obj)[index].

Answer 3

You need to create a Proxy class to substitute the return value of both methods. Then, in the Proxy class you can handle reads and writes appropriately. Here's code that should compile to demonstrate the idea (working with an array of unsigned integers):
typedef unsigned int UINT;
class A {
class Proxy {
public:
Proxy(const UINT &number): _number(number) {}
const Proxy &operator=(const Proxy &obj) {
cout << "Writting...\n";
_number = obj._number;
return *this;
}
operator const UINT &() const {
cout << "Reading...\n";
return _number;
}
private:
UINT _number;
};
public:
A(UINT *array): _array(array) {}
Proxy operator[](int index) {
return _array[index];
}
const Proxy operator[](int index) const {
return _array[index];
}
private:
UINT *_array;
};
int main(int argc, char** argv) {
UINT myArray[] = {0, 1, 2, 3, 4};
A a(myArray); // Normal A object
UINT num1 = a[1]; // Reading fine
a[1] = num1; // Writting fine
const A ca(myArray); // Constant A object
UINT num2 = ca[1]; // Reading fine
ca[1] = num2; // Writting NOT fine (compilation error)
return 0;
}

Answer 4

implement data& at(size_t i); and const data& cat(size_t); functions, so you can invoke cat() on non-const objects to enforce constness of returned data.

Answer 5

No, unless you cast the reference/pointer to a constant. Or create a constant copy.
A a;
const_cast<const A &> (a)[0] /*.foo ()*/;

Answer 6

If you are implementing copy-on-write, then you should not define those subscription operators at all. A client that calls the const version of the subscription method for an object x is not allowed to subsequently use that reference to modify a component of x, but the reference should still reflect the changes that other clients make to (that component of) x. But his is not going to happen with a copy-on-write strategy, since the change will happen in a different copy than the reference points to.
Also two clients that call the non-const subscription operator with the same index should get (modifyable) references to the same data object; but they won't, because two seperate copies will have been made when the subscription operators were called.
Instead you could have a subscription method that returns data by value. This avoids creating the illusion of obtaining an alias for a component of x (which as I argued must be illusory when copy-on-write is implemented). You could also provide a single method that modifies a component of x (rather than splitting this operation into a subscription followed by assignment to the reference so obtained), which would either internally make a copy, or just modify a component in place if this copy was already made. This would hide from clients the use of a copy-on-write implementation.
More generally, exposing methods that return references to internal objects, whether const or not, is exposing the implementation detail that such objects exist at all. This limits the freedom of changing the implementation later, for instance to compress the data or to store it elsewhere than in memory.