On 3 May 2010, at 12:39, Stewart, Robert wrote:
Chad Nelson wrote:
On 05/02/2010 04:19 PM, Jeffrey Lee Hellrung, Jr. wrote:
If something's not going to be modified, you might as well make it a constant reference.
I assume the savings come from somewhere else, since I already use constant references wherever I can get away with it.
The only example I can think of where COW might come in handy is if you do something like
cow* p_x1 = new cow(); cow* p_x2 = new cow(*p_x1); // no deep copy / shared ownership // ... [A] Read from *p_x1, maybe? ... delete p_x1; // *p_x2 now has exclusive ownership
If I read your example correctly, then that's about what I was thinking of: algorithms that have to start with a copy of one or more of the passed-in parameters, but then need to modify it/them. The division algorithm requires this, just as one example off the top of my head.
If your algorithm requires a copy, then COW should make it slower because it will first manipulate the reference count and because you must query in each mutating operation whether to make a unique copy.
But, you save the cost of copying a large object. COW has many disadvantages, but how can you claim it is slower when you require a copy? It is worth noting that all implementations of the C++ standard library have gone through a similar process to this. I believe they all started out using COW std::strings, and the standard was written with various special cases specifcally to allow them. Most implementations are now phasing them out, as they are expensive to make thread-safe, and rvalue references remove many (but by no means all) of the cases where they were useful. Chris