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

# QVarLengthArray Class Reference

The QVarLengthArray class provides a low-level variable-length array. More...

    #include <QVarLengthArray>

Note: All the functions in this class are reentrant.

- List of all members, including inherited members

### Public Functions

- QVarLengthArray ( int size = 0 )
- QVarLengthArray ( const QVarLengthArray & other )
- ~QVarLengthArray ()
- void append ( const T & t )
- void append ( const T * buf, int size )
- int capacity () const
- void clear ()
- const T * constData () const
- int count () const
- T * data ()
- const T * data () const
- bool isEmpty () const
- void reserve ( int size )
- void resize ( int size )
- int size () const
- QVarLengthArray & operator= ( const QVarLengthArray & other )
- T & operator[] ( int i )
- const T & operator[] ( int i ) const

## Detailed Description

The QVarLengthArray class provides a low-level variable-length array.

The C++ language doesn't support variable-length arrays on the stack. For example, the following code won't compile:

        int myfunc(int n)
        {
            int table[n + 1];  // WRONG
            ...
            return table[n];
        }

The alternative is to allocate the array on the heap (with `new`):

        int myfunc(int n)
        {
            int *table = new int[n + 1];
            ...
            int ret = table[n];
            delete[] table;
            return ret;
        }

However, if myfunc() is called very frequently from the application's inner loop, heap allocation can be a major source of slowdown.

QVarLengthArray is an attempt to work around this gap in the C++ language. It allocates a certain number of elements on the stack, and if you resize the array to a larger size, it automatically uses the heap instead. Stack allocation has the advantage that it is much faster than heap allocation.

Example:

        int myfunc(int n)
        {
            QVarLengthArray<int, 1024> array(n + 1);
            ...
            return array[n];
        }

In the example above, QVarLengthArray will preallocate 1024 elements on the stack and use them unless `n + 1` is greater than 1024. If you omit the second template argument, QVarLengthArray's default of 256 is used.

QVarLengthArray's value type must be an assignable data type. This covers most data types that are commonly used, but the compiler won't let you, for example, store a QWidget as a value; instead, store a QWidget *.

QVarLengthArray, like QVector, provides a resizable array data structure. The main differences between the two classes are:

- QVarLengthArray's API is much more low-level. It provides no iterators and lacks much of QVector's functionality.
- QVarLengthArray doesn't initialize the memory if the value is a basic type. (QVector always does.)
- QVector uses implicit sharing as a memory optimization. QVarLengthArray doesn't provide that feature; however, it usually produces slightly better performance due to reduced overhead.

Warning: QVector (or QList) is the right class for most applications, but if you need to write highly optimized code, QVarLengthArray may be appropriate.

See also QVector, QList, and QLinkedList.

## Member Function Documentation

### QVarLengthArray::QVarLengthArray ( int size = 0 )

Constructs an array with an initial size of size elements.

If the value type is a primitive type (e.g., char, int, float) or a pointer type (e.g., QWidget *), the elements are not initialized. For other types, the elements are initialized with a default-constructed value.

### QVarLengthArray::QVarLengthArray ( const QVarLengthArray & other )

Constructs a copy of other.

### QVarLengthArray::~QVarLengthArray ()

Destroys the array.

### void QVarLengthArray::append ( const T & t )

Appends item t to the array, extending the array if necessary.

### void QVarLengthArray::append ( const T * buf, int size )

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.

Appends size amount of items referenced by buf to this array.

### int QVarLengthArray::capacity () const

Returns the maximum number of elements that can be stored in the array without forcing a reallocation.

The sole purpose of this function is to provide a means of fine tuning QVarLengthArray's memory usage. In general, you will rarely ever need to call this function. If you want to know how many items are in the array, call size().

See also reserve().

### void QVarLengthArray::clear ()

Removes all the elements from the array.

Same as resize(0).

### const T * QVarLengthArray::constData () const

Returns a const pointer to the data stored in the array. The pointer can be used to access the items in the array. The pointer remains valid as long as the array isn't reallocated.

This function is mostly useful to pass an array to a function that accepts a plain C++ array.

See also data() and operator[]().

### int QVarLengthArray::count () const

Same as size().

See also isEmpty() and resize().

### T * QVarLengthArray::data ()

Returns a pointer to the data stored in the array. The pointer can be used to access and modify the items in the array.

Example:

        QVarLengthArray<int> array(10);
        int *data = array.data();
        for (int i = 0; i < 10; ++i)
            data[i] = 2 * i;

The pointer remains valid as long as the array isn't reallocated.

This function is mostly useful to pass an array to a function that accepts a plain C++ array.

See also constData() and operator[]().

### const T * QVarLengthArray::data () const

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.

### bool QVarLengthArray::isEmpty () const

Returns true if the array has size 0; otherwise returns false.

See also size() and resize().

### void QVarLengthArray::reserve ( int size )

Attempts to allocate memory for at least size elements. If you know in advance how large the array can get, you can call this function and if you call resize() often, you are likely to get better performance. If size is an underestimate, the worst that will happen is that the QVarLengthArray will be a bit slower.

The sole purpose of this function is to provide a means of fine tuning QVarLengthArray's memory usage. In general, you will rarely ever need to call this function. If you want to change the size of the array, call resize().

See also capacity().

### void QVarLengthArray::resize ( int size )

Sets the size of the array to size. If size is greater than the current size, elements are added to the end. If size is less than the current size, elements are removed from the end.

If the value type is a primitive type (e.g., char, int, float) or a pointer type (e.g., QWidget *), new elements are not initialized. For other types, the elements are initialized with a default-constructed value.

See also size().

### int QVarLengthArray::size () const

Returns the number of elements in the array.

See also isEmpty() and resize().

### QVarLengthArray & QVarLengthArray::operator= ( const QVarLengthArray & other )

Assigns other to this array and returns a reference to this array.

### T & QVarLengthArray::operator[] ( int i )

Returns a reference to the item at index position i.

i must be a valid index position in the array (i.e., 0 <= i < size()).

See also data().

### const T & QVarLengthArray::operator[] ( int i ) const

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.