/**************************************************************************** ** ** ** Qt template library classes documentation ** ** Copyright (C) 1992-2000 Trolltech AS. All rights reserved. ** ** This file is part of the Qt GUI Toolkit. ** ** This file may be distributed under the terms of the Q Public License ** as defined by Trolltech AS of Norway and appearing in the file ** LICENSE.QPL included in the packaging of this file. ** ** This file may be distributed and/or modified under the terms of the ** GNU General Public License version 2 as published by the Free Software ** Foundation and appearing in the file LICENSE.GPL included in the ** packaging of this file. ** ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition ** licenses may use this file in accordance with the Qt Commercial License ** Agreement provided with the Software. ** ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ** ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for ** information about Qt Commercial License Agreements. ** See http://www.trolltech.com/qpl/ for QPL licensing information. ** See http://www.trolltech.com/gpl/ for GPL licensing information. ** ** Contact info@trolltech.com if any conditions of this licensing are ** not clear to you. ** **********************************************************************/ /*! \page qtl.html \title Qt Template library Thq Qt Template Library is a set of templates within Qt dealing with containers of objects. It provides a list of objects, a stack of objects, a map (or dictionary) from one type to another, and associated iterators and algorithms. Qt also contains similar classes that deal with pointers to objects; \l QValueList vs. \l QList, etc. Compared to the pointer-based templates, the QTL offers easy copying of the container, real support for classes that e.g. require constructors, expand to much more object code, can often be a bit faster, require that the objects stored can be copied, and finally, have a worse record of compiler problems. Compared to the STL, the QTL contains only the most important features of the STL, has more regular function naming, has no platform differences, is often a little slower and often expands to less object code. If you can not make copies of the objects you want to store you are better off with QCollection and friends. They were designed to handle exactly that kind of pointer semantics. This applies for example to all classes derived from \l QObject. A QObject does not have a copy constructor, so using it as value is impossible. You may choose be store pointers to QObjects in a QValueList, but using QList directly seems to be the better choice for this kind of application domain. QList, like all other QCollection based containers, provides far more sanity checking than a speed-optimized value based container. If you have objects that implement value semantics, use the Qt template library. Value semantics require at least Note that a fast copy constructor is absolutely crucial for a good overall performance of the container, since many copy operations are going to happen. Examples for value based classes are QRect, QPoint, QSize and all simple C++ types like int, bool or double. The Qt template library is designed for speed. Especially iterators are extremely fast. On the drawback side, less error checking is done than in the QCollection based containers. A template library container for example does not track associated iterators. This makes certain validity checks, like on removing items, impossible to perform automatically.

Iterators

The Qt template library deals with value objects, not with pointers. For that reason, there is no other way of iterating over containers than using iterators. This is no disadvantage as the size of an iterator matches the size of a normal pointer - 32 or 64 bits depending on your CPU architecture. To iterate over a container, use a loop like this: \code typedef QValueList List; List l; for( List::Iterator it = l.begin(); it != l.end(); ++it ) printf("Number is %i\n",*it); \endcode begin() returns the iterator pointing at the first element, while end() returns an iterator that points \e after the last element. end() marks an invalid position, it can never be dereferenced. It's the break condition in any iteration, may it be from begin() or fromLast(). For maximum speed, use increment or decrement iterators with the prefix operator (++it, --it) instead of the the postfix one (it++, it--), since the former is slightly faster. The same concept applies to the other container classes: \code typedef QMap Map; Map map; for( Map::Iterator it = map.begin(); it != map.end(); ++it ) printf("Key=%s Data=%s\n", it.key().ascii(), it.data().ascii() ); typedef QArray Array; Array array; for( Array::Iterator it = array.begin(); it != array.end(); ++it ) printf("Data=%i\n", *it ); \endcode There are two kind of iterators, the volatile iterator shown in the examples above and a version that returns a const reference to its current object, the ConstIterator. Const iterators are required whenever the container itself is const, such as a member variable inside a const function. Assigning a ConstIterator to a normal Iterator is not allowed as it would violate const semantics.

Algorithms

The template library defines a number of algorithms that operate on its containers: qHeapSort(), qBubbleSort(), qSwap() and qCopy(). These algorithms are implemented as template functions. qHeapSort() and qBubbleSort() provide the well known sorting algorithms. You can use them like this: \code typedef QValueList List; List l; l << 42 << 100 << 1234 << 12 << 8; qHeapSort( l ); List l2; l2 << 42 << 100 << 1234 << 12 << 8; List::Iterator b = l2.find( 100 ); List::Iterator e = l2.find( 8 ); qHeapSort( b, e ); double arr[] = { 3.2, 5.6, 8.9 }; qHeapSort( arr, arr + 3 ); \endcode The first example sorts the entire list. The second one sorts all elements enclosed in the two iterators, namely 100, 1234 and 12. The third example shows that iterators act like pointers and can be treated as such. Naturally, the sorting templates won't work with const iterators. Another utility is qSwap(). It exchanges the values of two variables: \code QString second( "Einstein" ); QString name( "Albert" ); qSwap( second, name ); \endcode Another template function is qCopy(). It copies a container or a slice of it to an OutputIterator, in this case a QTextOStreamIterator: \code typedef QValueList List; List l; l << 100 << 200 << 300; QTextOStream str( stdout ); qCopy( l, QTextOStreamIterator( str ) ); \endcode In addition, you can use any Qt template library iterator as the OutputIterator. Just make sure that the right hand of the iterator has as many elements present as you want to insert. The following example illustrates this: \code QStringList l1, l2; l1 << "Weis" << "Ettrich" << "Arnt" << "Sue"; l2 << "Torben" << "Matthias"; qCopy( l2, l1.begin(); \endcode At the end of this code fragment, the List l1 contains "Torben", "Matthias", "Arnt" and "Sue", with the prior contents being overwritten. Another flavor of qCopy() takes three arguments to make it possible to copy a slice of a container: \code typedef QValueList List; List l; l << 42 << 100 << 1234 << 12 << 8; List::Iterator b = l.find( 100 ); List::Iterator e = l.find( 8 ); QTextOStream str( stdout ); qCopy( b, e, QTextOStreamIterator( str ) ); \endcode If you write new algorithms, consider writing them as template functions in order to make them usable with as many containers possible. In the above example, you could just as easily print out a standard C++ array with qCopy(): \code int arr[] = { 100, 200, 300 }; QTextOStream str( stdout ); qCopy( arr, arr + 3, QTextOStreamIterator( str ) ); \endcode

Streaming

All mentioned containers can be serialized with the respective streaming operators. Here is an example. \code QDataStream str(...); QValueList l; // ... fill the list here str << l; \endcode The container can be read in again with: \code QValueList l; str >> l; \endcode The same applies to QStringList, QValueStack and QMap. */