What to do with proxy class copy-assignment operator?

Question

Consider the following proxy class:

class VertexProxy
{
public:
    VertexProxy(double* x, double* y, double* z)
    : x_(x), y_(y), z_(z) {}

    VertexProxy(const VertexProxy& rhs)
    : x_(rhs.x_), y_(rhs.y_), z_(rhs.z_) {}

    // Coordinate getters
    double x() const {return *x_;}
    double y() const {return *y_;}
    double z() const {return *z_;}

    // Coordinate setters
    VertexProxy& x(double val) {*x_ = val; return *this;}
    VertexProxy& y(double val) {*y_ = val; return *this;}
    VertexProxy& z(double val) {*z_ = val; return *this;}

    VertexProxy& operator=(const VertexProxy& rhs)
    {
        // Should it be this
        x_ = rhs.x_; y_ = rhs.y_; z_ = rhs.z_;

        // or this?
        *x_ = *rhs.x_; *y_ = *rhs.y_; *z_ = *rhs.z_;

        return *this;
    }

private:
    double* x_; double* y_; double* z_;
};

I need to be able to reset the proxy so that it holds different coordinate pointers (similarly to boost::shared_ptr.reset(). In addition, I would like to be able to assign the coordinate values to the ones from a different proxy ( i.e. proxy1.assign(proxy2) ).

What should be the meaning of operator= in my class above? To copy rhs's pointers (shallow copy) or rhs's values? Or should I just make operator= private and provide two members functions to avoid the ambiguity of operator=?

EDIT:

Ok, here's some background information. I'm writing a wrapper around a 3rd party GIS library (shapelib), which stores vertex coordinates (x,y,z,m) in separate arrays (instead of an array of structs). My proxy class is used to make this struct of arrays appear more like an array of structs. It works in tandem with a custom vertex iterator class that makes it much easier to work with ranges of vertices.

Shapelib handles the memory management. All my proxy class does is present a different "view" into the vertex data. When the user manipulates vertex coordinates using my proxy, it actually manipulates the vertex coordinates in the shapelib shape object.

Answer 1

I would say that it depends on how large the object is.

If the proxy subject is very big then using a reference counting shared pointer is the way to go. Just copy the shared pointer in the copy operation.

If it isn't that big then a deep copy is better. Less hassle all around for everyone.

Answer 2

It's pretty simple. Do you want VertexProxy to act like a pointer, or a value? If you'd rather it acted like a pointer, then copy the pointers, if you'd rather it acted like a value, copy the values. Nobody can tell you that your class is a pointer or a value (especially since you seem to have something somewhat unusual). If you want better advice, we'd need to know what holds the actual doubles and why.

Quick edit: Seems to me like actually, if you did the dereference, you'd have it acting like a reference or a pointer. However, the original point remains the same.

Answer 3

Given that your copy constructor copies the pointers, for consistency your copy-assignment operator should assign the pointers.

VertexProxy& operator=(const VertexProxy& rhs)
{
    x_ = rhs.x_;
    y_ = rhs.y_;
    z_ = rhs.z_;

    return *this;
}

It would be very inconsistent if this (admittedly questionable) code:

VertexProxy test( const VertexProxy& other )
{
    double tmp1, tmp2, tmp3;
    VertexProxy p1( &tmp1, &tmp2, &tmp3 );
    p1 = other;
    return p1;
}

acted differently to:

VertexProxy test( const VertexProxy& other )
{
    double tmp1, tmp2, tmp3; // unused
    VertexProxy p1( other );
    return p1;
}

Answer 4

std::bitset::reference performs a role similar to my VertexProxy and can be used as a model.

typedef std::bitset<8> Bitset;
Bitset bset1, bset2;
Bitset::reference r1(bset1[3]);
Bitset::reference r2(bset2[3]);
r1 = 1;
r2 = r1;
std::cout << "bset2 = " << bset2 << "\n";

r2 = r1 above copies values.