immutable strings vs std::string

Question

I've recent been reading about immutable strings, here and here as well some stuff about why D chose immutable strings. There seem to be many advantages.

• trivially thread safe
• more secure
• more memory efficient in most use cases.
• cheap substrings (tokenizing and slicing)

Not to mention most new languages have immutable strings, D2.0, Java, C#, Python, Ruby, etc.

Would C++ benefit from immutable strings?

Is it possible to implement an immutable string class in c++ (or c++0x) that would have all of these advantages?

---

update:

There are two attempts at immutable strings const_string and fix_str. Neither have been updated in half a decade. Are they even used? Why didn't const_string ever make it into boost?

Answer 1

const std::string

There you go. A string literal is also immutable, unless you want to get into undefined behavior.

Edit: Of course that's only half the story. A const string variable isn't useful because you can't make it reference a new string. A reference to a const string would do it, except that C++ won't allow you to reassign a reference as in other languages like Python. The closest thing would be a smart pointer to a dynamically allocated string.

Answer 2

As an opinion:

• Yes, I'd quite like an immutable string library for C++.
• No, I would not like std::string to be immutable.

Is it really worth doing (as a standard library feature)? I would say not. The use of const gives you locally immutable strings, and the basic nature of systems programming languages means that you really do need mutable strings.

Answer 3

You're certainly not the only person who though that. In fact, there is const_string library by Maxim Yegorushkin, which seems to have been written with inclusion into boost in mind. And here's a little newer library, fix_str by Roland Pibinger. I'm not sure how tricky would full string interning at run-time be, but most of the advantages are achievable when necessary.

Answer 4

Qt also uses immutable strings with copy-on-write.
There is some debate about how much performance it really buys you with decent compilers.

Answer 5

constant strings make little sense with value semantics, and sharing isn't one of C++'s greatest strengths...

Answer 6

I don't think there's a definitive answer here. It's subjective - if not because personal taste then at least because of the type of code one most often deals with. (still, a valuable question).

Immutable strings are great when memory is cheap - this wasn't true when C++ was developed, and it isn't the case on all platforms targeted by C++. (OTOH on more limited platforms C seems much more common than C++, so that argument is weak.)

You can create an immutable string class in C++, and you can make it largely compatible with std::string - but you will still lose when comparing to a built-in string class with dedicated optimizations and language features.

std::string is the best standard string we get, so I wouldn't like to see any messing with it. I use it very rarely, though, std::string has to many drawbacks from my point of view.

Answer 7

We have imutable strings.

char const* const string = "Plop";

Lets compare:

* trivially thread safe
    YES:  
* more secure
    YES:
    Most compiler will put this in a read only segment(check your compiler doc for details)
* more memory efficient in most use cases.
    YES.
* cheap substrings (tokenizing and slicing)
    With a tiny bit of work.

Answer 8

Some people just don't use unbounded mutable or immutable strings. That simples up the problem pretty well.