Home | All Classes | Main Classes | Annotated | Grouped Classes | Functions |

# Qt Template Library

The Qt Template Library (QTL) is a set of templates that provide object containers. If a suitable STL implementation is not available for your compiler, the QTL can be used instead. It provides a list of objects, a vector (dynamic array) of objects, a map (or dictionary) from one type to another, and associated iterators and algorithms. A container is an object which contains and manages other objects and provides iterators that allow the contained objects to be accessed.

The QTL classes' naming conventions are consistent with the other Qt classes (e.g., count(), isEmpty()). They also provide extra functions for compatibility with STL algorithms, such as size() and empty(). Programmers already familiar with the STL `map` can use these functions instead.

Compared to the STL, the QTL contains only the most important features of the STL container API, has no platform differences, is often a little slower and often expands to less object code.

If you cannot make copies of the objects you want to store you are better off with QPtrCollection and friends. They were designed to handle exactly that kind of pointer semantics. This applies for example to all classes derived from QObject. A QObject does not have a copy constructor, so using it as value is impossible. You may choose to store pointers to QObjects in a QValueList, but using QPtrList directly seems to be the better choice for this kind of application domain. QPtrList, like all other QPtrCollection based containers, provides far more sanity checking than a speed-optimized value based container.

If you have objects that implement value semantics, and the STL is not available on your target platform, the Qt Template Library can be used instead. Value semantics require at least

- a copy constructor,
- an assignment operator and
- a defaultconstructor, i.e. a constructor that does not take any arguments.

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.

If you intend sorting your data you must implement operator<() for your data's class.

Good candidates for value based classes are QRect, QPoint, QSize, QString and all simple C++ types, such as int, bool or double.

The Qt Template Library is designed for speed. Iterators are extremely fast. To achieve this performance, less error checking is done than in the QPtrCollection based containers. A QTL container, for example, does not track any associated iterators. This makes certain validity checks, for example when removing items, impossible to perform automatically, however it provides extremely good performance.

## Iterators

The Qt Template Library deals with value objects, not with pointers. For that reason, there is no other way of iterating over containers other than with iterators. This is no disadvantage as the size of an iterator matches the size of a normal pointer.

To iterate over a container, use a loop like this:

        typedef QValueList<int> List;
        List l;
        for( List::Iterator it = l.begin(); it != l.end(); ++it )
            printf( "Number is %i\n", *it );

begin() returns the iterator pointing at the first element, while end() returns an iterator that points 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 postfix one (it++, it--), since the former is slightly faster.

The same concept applies to the other container classes:

        typedef QMap<QString,QString> 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 QValueVector<int> Vector;
        Vector vec;
        for( Vector::iterator it = vec.begin(); it != vec.end(); ++it )
            printf( "Data=%d\n", *it );

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 Qt Template Library defines a number of algorithms that operate on its containers. These algorithms are implemented as template functions and provide useful generic code which can be applied to any container that provides iterators (even your own containers).

qHeapSort() and qBubbleSort() provide the well known sorting algorithms. You can use them like this:

        typedef QValueList<int> 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 );

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.

If using your own data types you must implement operator<() for your data's class.

Naturally, the sorting templates won't work with const iterators.

Another utility is qSwap(). It exchanges the values of two variables:

        QString second( "Einstein" );
        QString name( "Albert" );
        qSwap( second, name );

Another template function is qCount(). It counts the number of occurrences of a value within a container. For example:

        QValueList<int> l;
        l.push_back( 1 );
        l.push_back( 1 );
        l.push_back( 1 );
        l.push_back( 2 );
        int c = 0;
        qCount( l.begin(), l.end(), 1, c ); // c == 3

Another template function is qFind. It find the first occurrence of a value within a container. For example:

        QValueList<int> l;
        l.push_back( 1 );
        l.push_back( 1 );
        l.push_back( 1 );
        l.push_back( 2 );
        QValueListIterator<int> it = qFind( l.begin(), l.end(), 2 );

Another template function is qFill. It fills a range with copies of a value. For example:

        QValueVector<int> v(3);
        qFill( v.begin(), v.end(), 99 ); // v contains 99, 99, 99

Another template function is qEqual. It compares two ranges for equality of their elements. Note that the number of elements in each range is not considered, only if the elements in the first range are equal to the corresponding elements in the second range (consequently, both ranges must be valid). For example:

        QValueVector<int> v1(3);
        v1[0] = 1;
        v1[2] = 2;
        v1[3] = 3;

        QValueVector<int> v2(5);
        v1[0] = 1;
        v1[2] = 2;
        v1[3] = 3;
        v1[4] = 4;
        v1[5] = 5;

        bool b = qEqual( v1.begin(), v2.end(), v2.begin() );
        // b == TRUE

Another template function is qCopy(). It copies a range of elements to an OutputIterator, in this case a QTextOStreamIterator:

        QValueList<int> l;
        l.push_back( 100 );
        l.push_back( 200 );
        l.push_back( 300 );
        QTextOStream str( stdout );
        qCopy( l.begin(), l.end(), QTextOStreamIterator(str) );

Here is another example which copies a range of elements from one container into another. It uses the qBackInserter() template function which creates a QBackInsertIterator<> whose job is to insert elements into the end of a container. For example:

        QValueList<int> l;
        l.push_back( 100 );
        l.push_back( 200 );
        l.push_back( 300 );
        QValueVector<int> v;
        qCopy( l.begin(), l.end(), qBackInserter(v) );

Another template function is qCopyBackward(). It copies a container or a slice of it to an OutputIterator, but in backwards fashion, for example:

        QValueVector<int> vec(3);
        vec.push_back( 100 );
        vec.push_back( 200 );
        vec.push_back( 300 );
        QValueVector<int> another;
        qCopyBackward( vec.begin(), vec.end(), another.begin() );
        // 'another' now contains 100, 200, 300
        // however the elements are copied one at a time
        // in reverse order (300, 200, then 100)

Another template function is qMakePair(). This is a convenience function which is used for creating QPair<> objects. For example:

        QMap<QString,QString> m;
        m.insert( qMakePair("Clinton", "Bill") );

The above code is equivalent to:

        QMap<QString,QString> m;
        QPair<QString,QString> p( "Clinton", "Bill" );
        m.insert( p );

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:

        QStringList l1, l2;
        l1 << "Weis" << "Ettrich" << "Arnt" << "Sue";
        l2 << "Torben" << "Matthias";
        qCopy( l2.begin(), l2.end(), l1.begin() );

        QValueVector<QString> v( l1.size(), "Dave" );
        qCopy( l2.begin(), l2.end(), v.begin() );

At the end of this code fragment, the list l1 contains "Torben", "Matthias", "Arnt" and "Sue", with the prior contents being overwritten. The vector v contains "Torben", "Matthias", "Dave" and "Dave, also with the prior contents being overwritten.

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():

        int arr[] = { 100, 200, 300 };
        QTextOStream str( stdout );
        qCopy( arr, arr + 3, QTextOStreamIterator( str ) );

## Streaming

All mentioned containers can be serialized with the respective streaming operators. Here is an example.

        QDataStream str(...);
        QValueList<QRect> l;
        // ... fill the list here
        str << l;

The container can be read in again with:

        QValueList<QRect> l;
        str >> l;

The same applies to QStringList, QValueStack and QMap.