QVarLengthArray Class Reference

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

 #include <QVarLengthArray>

Note: All functions in this class are reentrant.

List of all members, including inherited members

Public Types

typedef	const_pointer
typedef	const_reference
typedef	difference_type
typedef	pointer
typedef	reference
typedef	size_type
typedef	value_type

Public Functions

	QVarLengthArray ( int size = 0 )
	QVarLengthArray ( const QVarLengthArray<T, Prealloc> & other )
	~QVarLengthArray ()
void	append ( const T & t )
void	append ( const T * buf, int size )
const T &	at ( int i ) const
int	capacity () const
void	clear ()
const T *	constData () const
int	count () const
T *	data ()
const T *	data () const
bool	isEmpty () const
void	removeLast ()
void	reserve ( int size )
void	resize ( int size )
int	size () const
T	value ( int i ) const
T	value ( int i, const T & defaultValue ) const
QVarLengthArray<T, Prealloc> &	operator= ( const QVarLengthArray<T, Prealloc> & 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, especially in tight loops.

In summary, QVarLengthArray is a low-level optimization class that only makes sense in very specific cases. It is used a few places inside Qt and was added to Qt's public API for the convenience of advanced users.

See also QVector, QList, and QLinkedList.