Comments on: I Didn’t Order That, So Why Is It On My Bill, Episode 2

By: dv

dv — Thu, 07 Jan 2010 15:08:15 +0000

Update: I was mistaken about the LHS-RHS-preferences. C++ always prefers the LHS version over the RHS one. For some reason, the RHS one was preferred in my tests. This means the crazy cast is indeed necessary.

By: dv

dv — Thu, 07 Jan 2010 15:01:58 +0000

Please note that your code makes a big mistake: it always invokes the LHS version of the [] operator. In other words, the expression “the_copy[0];” is NOT a simple read. You should use “char c = the_copy[0];” instead, since this uses the RHS operator. This one cannot write, so it does not have to copy.

LHS version: char & operator[](size_type const index)
RHS version: char const & operator[](size_type const index) const

LHS examples:
the_copy[0];
the_copy[0] = ‘a’;

RHS example:
std::cout << the_copy[0];

What "const_cast(the_base)[0];” does is simply force the_base to be const, so that the only matching [] operator is the RHS one.

As for COW in gcc 4.x, it does exist. Just look into the basic_string header. However, they use atomic operations instead of mutexes/critical sections.

By: Anonymous

Anonymous — Wed, 23 Sep 2009 23:07:42 +0000

I understand that C++0x adds some things to strings so that CoW will no longer be feasible.

By: ridiculous_fish

ridiculous_fish — Fri, 18 Sep 2009 19:36:39 +0000

Heh, didn’t even realize I was justifying. Left-align, activate!

By: Leonardo Boiko

Leonardo Boiko — Fri, 18 Sep 2009 19:26:19 +0000

Justification simply doesn’t work on the Web. Good justification needs sophisticated hyphenation algorithms, language-specific information, and mechanisms for fine-tuning, a la LaTeX. Our current crop of *standards* don’t support any of that, never mind the browsers. One should just use left-align, at least until 2077 when CSS3 decides to define hyphenation support. Otherwise, you end up with awfully stretched inter-word spacing or even intra-word spacing, depending on your window size, font, and browser.

By: Alex

Alex — Fri, 18 Sep 2009 10:07:48 +0000

You fail. This is what const_iterators are for.

By: rmn

rmn — Fri, 18 Sep 2009 08:47:28 +0000

Michael Pyne, this code will not achieve the desired behaviour. C++ does not choose which function to invoke by inspecting the context; it does not matter that the return value is conse char& and not just char&. The invoked function will be the non const operator[] (and not operator[] const), since the string itself is not const.
What you could do to get the desired behavior is use the code in Anonymous’s comment, which makes the call to operator[] through a const string.

Regards,
Roman.

By: Michael Pyne

Michael Pyne — Fri, 18 Sep 2009 00:49:11 +0000

Another method which is common (and which I’m surprised didn’t work when I tested it) is if you want only a read-only reference, to use a const return variable. i.e.:

const char& first = the_base[2];

This allows the string class to use it’s const member function
const char& operator[](int) const;

to fulfill the request with the assurance that the recipient of the char won’t do anything tricky. GNU STL doesn’t seem to take advantage of that here though, as this case is still as slow as the other COW-breakers.

(I mention this because it’s used all the time in Qt, where it works as designed.

By: rmn

rmn — Thu, 17 Sep 2009 21:15:44 +0000

Hi fish,
As far as I know, the standard does not deman std::string to use COW – that’s just what your implementation does. That’s why the interface is that way. It’s alot more user friendly as well.

Thanks for the reply.

By: tod(D)

tod(D) — Thu, 17 Sep 2009 20:53:55 +0000

As others have said, copy-on-write performs terribly if you try to make it thread safe (and who wants a low level thing like std::string that isn’t threadsafe?), one of the reasons it has dropped from most standard libraries and effectively rendered illegal in c++0x (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2668.htm).

If you need to accomplish fast, low overhead copies, the flyweight pattern (http://www.boost.org/doc/libs/1_40_0/libs/flyweight/doc/index.html) performs better and is far more extensible than just rendering all strings immutable.