Re: const and proxies of objects
* ciccio, on 02.06.2010 15:47:
I would like to create some kind of object and proxies of that
object. A simple example would be a vector and the proxy is then a
subvector.
Assume I have the following array class that contains a simple array
definition
class array {
public:
typedef unsigned int size_type;
array() : data_(0), size_(0) {}
array(size_type size) { /* definition here */ }
array(const array&c) { /* copy constructor */ }
// all requested functions and operators here
private:
double * data_;
size_type size_;
};
As long you're using a raw array as the represention you'll also need to define
a destructor and a copy assignment operator (or at least declare them). This is
known as the "law of 3". If you need any single one of copy constructor,
destructor or copy assignment operator, you probably need all three.
If not then you'll leak memory and do double deallocations to compensate...
By the way, emulating the standard library wrt. definining local size types
everywhere is just added complication for strictly negative gain. I.e., it's
silly. :-) Just Say No(TM) to that idea.
This array class would then contain the data of my vector.
The private data members of the vector class are then an array
and an array reference. The reference is used for all data access and
thus in all functions. The vector constructors set the reference.
In case of a proxy, the reference is set to data of the original.
class vector {
public:
typedef array::size_type size_type;
vector() : _data_(), data_(_data_) { /* def here */ }
vector(size_type size) : _data_(size), data_(_data_) {
/* def here */
}
vector(const vector&c) : _data_(c.data_), data_(_data_) {
/* def here */
}
// proxy
vector(const vector&p, int i) : _data_(), data_(p.data_) {
// stuff where i can be used for, ex. different length
}
// all requested functions and operators here
private:
array _data_;
array&data_;
// bunch of variables you want here (size, begin, end, stride)
};
The usual name for this kind of thing is "slice". Another good reason to change
the name is that we already have 'std::vector'.
Check out std::valarray (??26.3 of C++98 standard).
I haven't used it but it's there, and it might free you for implementing this
yourself.
The question I have no concerns the proxy constructor, i.e
vector(const vector&p, int i) : _data_(), data_(p.data_) {
// stuff where i can be used for, ex. different length
}
The constructor takes a const vector reference p, and creates a new
vector that can alter the data members of p afterwards. This could be
done by means of other functions. (Ex.
vector v(20); // vector v of size 20
vector p(v,10) // vector p has same elements of v but only address
// first 10
p(1) = 1.0;
How correct is this with respect to the idea of const?
As far as I understand your intention it isn't const-correct, really. There is
about the same problem with a smart pointer but we accept it for the smart
pointer because the constness of the smart pointer does not relate to the
constness of the pointee. However in your case you have a wrapper whose
constness or not presumably is meant to restrict (or not) available operations.
It is extremely dangerous to use a copy constructor to do anything else than
actual /copying/. For one, the compiler is free to assume that a copy
constructor just copies, and optimize away a copy constructor call. For another
reason, programmers also expect a copy constructor to actually copy.
E.g., add a method ref() that produces a Ref, and a constructor that takes a
Ref. Don't try to make everything automatic, implicit and hidden, which IMO is
bad (except for all the exceptions to that rule, he he). Explicit is good.
I could define the constructor as
vector(vector&p, int i) : _data_(), data_(p.data_) {
// stuff where i can be used for, ex. different length
}
but this would make it impossible to use
vector(vector(p,i),j)
because of the dangling temporary that one of the references has.
slice( slice( p, i ).ref(), j )
So, how far should the const keyword reach? If an object is defined as
const, should the proxies or all derived objects also be consts?
Depends; see comment about smart pointer above.
Cheers & hth.,
- Alf
--
blog at <url: http://alfps.wordpress.com>