Subject: This is what we found out

From: Ellen's Secretly Using This <[email-masked]>
Date: Thu, 22 May 2014 07:31:03 -0700

TMV

Rumors are going around that Ellen DeGeneres got a face lift, because she is looking better then she ever has.

For the record:
She did NOT get a facelift.

In fact, many celebrities are now using this:
This is it: http://www.sorteft.com/TMV-Google-Ellen/leaked-pics-face/index.html

We were shocked to fond out how simple it is.

===

Thanks,
Kim Parker
(Good Housekeeping Editor)

(Latest Comments) | Share | Like
---------------------------------
Samantha H: She looks very good. I'm going to try this.
---
Linda P: If only I would have seen this episode sooner. Thank You DOC.OZ
----
Mary H: Where do i get this?
----
Tammy S: @Mary you can see the EP here and get it http://www.sorteft.com/TMV-Google-Ellen/leaked-pics-face/index.html
----
Cara T: I love Oz. He is so AWESOME! Thanks I can wait to get it.

--- See-More-On-Our-Page ---

Wanting to end-messages from GHP Creative-Resource : Thirty Estate : Forney
TX Seven Five ONe Two Six : http://www.sorteft.com/G695_-_-.html

Have a good Memorial Day.

What are the pros and cons of using Qt containers (QMap, QVector, etc.) over their STL equivalent?

I can see one reason to prefer Qt:

Qt containers can be passed along to other parts of Qt. For example, they can be used to populate a QVariant and then a QSettings (with some limitation though, only QList and QMap/QHash whose keys are strings are accepted).
Is there any other?

Edit: Assuming the application already relies on Qt.

I started by using std::(w)string and the STL containers exclusively and converting to/from the Qt equivalents, but I have already switched to QString and I find that I'm using Qt's containers more and more.

When it comes to strings, QString offers much more complete functionality compared to std::basic_string and it is completely unicode aware. It also offers an efficient COW implementation, which I've come to rely on heavily.

Qt's containers:

offer the same COW implementation as in QString, which is extremely useful when it comes to using Qt's foreach macro (which does a copy) and when using metatypes or signals and slots.
can use STL-style iterators or Java-style iterators
are streamable with QDataStream
are used extensively in Qt's API
have a stable implementation accross operating systems. A STL implementation must obey the C++ standard, but is otherwise free to do as it pleases (see the std::string COW controversy). Some STL implementations are especially bad.
provide hashes, which are not available unless you use TR1
The QTL has a different philosophy from the STL, which is well summarized by J. Blanchette: "Whereas STL's containers are optimized for raw speed, Qt's container classes have been carefully designed to provide convenience, minimal memory usage, and minimal code expansion."
The above link provides more details about the implementation of the QTL and what optimizations are used.]

The Qt containers are more limited than the STL ones. A few examples of where the STL ones are superior (all of these I have hit in the past):

STL is standardized, doesn't change with every Qt version (Qt 2 had QList (pointer-based) and QValueList (value-based); Qt 3 had QPtrList and QValueList; Qt 4 now has QList, and it's nothing at all like QPtrList or QValueList).
Even if you end up using the Qt containers, use the STL-compatible API subset (ie. push_back(), not append(); front(), not first(), ...) to avoid porting yet again come Qt 5. In both Qt2->3 and Qt3->4 transitions, the changes in the Qt containers were among those requiring the most code churn.
STL bidirectional containers all have rbegin()/rend(), making reverse iteration symmetric to forward iteration. Qt containers have no such thing, so reverse iteration is needlessly complicated.
STL algorithms have range-insert() from different, but compatible, iterator types, making std::copy() much less often needed.
STL containers have an Allocator template argument, making custom memory management trivial (typedef required), compared with Qt (fork of QLineEdit required for s/QString/secqstring/).
There's no Qt equivalent to std::deque.
std::list has splice(). Whenever I find myself using std::list, it's because I need splice().
std::stack, std::queue properly aggregate their underlying container, and don't inherit it, as QStack, QQueue do.
QSet is like std::unordered_set, not like std::set.
QList is a just weird.