From ea318d1431c89e647598c510c4245c6571aa5f46 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Thu, 26 Jan 2012 23:32:43 -0600 Subject: Update to latest tqt3 automated conversion --- doc/html/qvaluevector.html | 666 --------------------------------------------- 1 file changed, 666 deletions(-) delete mode 100644 doc/html/qvaluevector.html (limited to 'doc/html/qvaluevector.html') diff --git a/doc/html/qvaluevector.html b/doc/html/qvaluevector.html deleted file mode 100644 index e33fb7611..000000000 --- a/doc/html/qvaluevector.html +++ /dev/null @@ -1,666 +0,0 @@ - - - - - -TQValueVector Class - - - - - - - -
- -Home - | -All Classes - | -Main Classes - | -Annotated - | -Grouped Classes - | -Functions -

TQValueVector Class Reference

- -

The TQValueVector class is a value-based template class that provides a dynamic array. -More... -

All the functions in this class are reentrant when TQt is built with thread support.

-

#include <qvaluevector.h> -

List of all member functions. -

Public Members

- -

Detailed Description

- - -The TQValueVector class is a value-based template class that provides a dynamic array. -

- - - - -

TQValueVector is a TQt implementation of an STL-like vector -container. It can be used in your application if the standard vector is not available for your target platforms. TQValueVector is -part of the TQt Template Library. -

TQValueVector<T> defines a template instance to create a vector -of values that all have the class T. TQValueVector does not store -pointers to the members of the vector; it holds a copy of every -member. TQValueVector is said to be value based; in contrast, -TQPtrList and TQDict are pointer based. -

TQValueVector contains and manages a collection of objects of type -T and provides random access iterators that allow the contained -objects to be addressed. TQValueVector owns the contained -elements. For more relaxed ownership semantics, see TQPtrCollection -and friends, which are pointer-based containers. -

TQValueVector provides good performance if you append or remove -elements from the end of the vector. If you insert or remove -elements from anywhere but the end, performance is very bad. The -reason for this is that elements must to be copied into new -positions. -

Some classes cannot be used within a TQValueVector: for example, -all classes derived from TQObject and thus all classes that -implement widgets. Only values can be used in a TQValueVector. To -qualify as a value the class must provide: -

-

Note that C++ defaults to field-by-field assignment operators and -copy constructors if no explicit version is supplied. In many -cases this is sufficient. -

TQValueVector uses an STL-like syntax to manipulate and address the -objects it contains. See this document for -more information. -

Example: -

-    #include <qvaluevector.h>
-    #include <qstring.h>
-    #include <stdio.h>
-
-    class Employee
-    {
-    public:
-        Employee(): s(0) {}
-        Employee( const TQString& name, int salary )
-            : n( name ), s( salary )
-        { }
-
-        TQString name()   const          { return n; }
-        int     salary() const          { return s; }
-        void    setSalary( int salary ) { s = salary; }
-    private:
-        TQString n;
-        int     s;
-    };
-
-    int main()
-    {
-        typedef TQValueVector<Employee> EmployeeVector;
-        EmployeeVector vec( 3 );  // vector of 3 Employees
-
-        vec[0] = Employee( "Bill", 50000 );
-        vec[1] = Employee( "Steve", 80000 );
-        vec[2] = Employee( "Ron", 60000 );
-
-        Employee joe( "Joe", 50000 );
-        vec.push_back( joe );  // vector expands to accommodate 4 Employees
-        joe.setSalary( 70000 );
-        
-        EmployeeVector::iterator it;
-        for( it = vec.begin(); it != vec.end(); ++it )
-            printf( "%s earns %d\n", (*it).name().latin1(), (*it).salary() );
-
-        return 0;
-    }
-
- -

Program output: -

-        Bill earns 50000
-        Steve earns 80000
-        Ron earns 60000
-        Joe earns 50000
-
- -

As you can see, the most recent change to Joe's salary did not -affect the value in the vector because the vector created a copy -of Joe's entry. -

Many TQt functions return const value vectors; to iterate over -these you should make a copy and iterate over the copy. -

There are several ways to find items in the vector. The begin() -and end() functions return iterators to the beginning and end of -the vector. The advantage of getting an iterator is that you can -move forward or backward from this position by -incrementing/decrementing the iterator. The iterator returned by -end() points to the element which is one past the last element in -the container. The past-the-end iterator is still associated with -the vector it belongs to, however it is not dereferenceable; -operator*() will not return a well-defined value. If the vector is -empty(), the iterator returned by begin() will equal the iterator -returned by end(). -

The fastest way to access an element of a vector is by using -operator[]. This function provides random access and will return -a reference to the element located at the specified index. Thus, -you can access every element directly, in constant time, providing -you know the location of the element. It is undefined to access -an element that does not exist (your application will probably -crash). For example: -

-    TQValueVector<int> vec1;  // an empty vector
-    vec1[10] = 4;  // WARNING: undefined, probably a crash
-
-    TQValueVector<TQString> vec2(25); // initialize with 25 elements
-    vec2[10] = "Dave";  // OK
-
- -

Whenever inserting, removing or referencing elements in a vector, -always make sure you are referring to valid positions. For -example: -

-    void func( TQValueVector<int>& vec )
-    {
-        if ( vec.size() > 10 ) {
-            vec[9] = 99; // OK
-        }
-    };
-
- -

The iterators provided by vector are random access iterators, -therefore you can use them with many generic algorithms, for -example, algorithms provided by the STL or the TQTL. -

Another way to find an element in the vector is by using the -std::find() or qFind() algorithms. -For example: -

-    TQValueVector<int> vec;
-    ...
-    TQValueVector<int>::const_iterator it = qFind( vec.begin(), vec.end(), 3 );
-    if ( it != vector.end() )
-        // 'it' points to the found element
-
- -

It is safe to have multiple iterators on the vector at the same -time. Since TQValueVector manages memory dynamically, all iterators -can become invalid if a memory reallocation occurs. For example, -if some member of the vector is removed, iterators that point to -the removed element and to all following elements become -invalidated. Inserting into the middle of the vector will -invalidate all iterators. For convenience, the function back() -returns a reference to the last element in the vector, and front() -returns a reference to the first element. If the vector is -empty(), both back() and front() have undefined behavior (your -application will crash or do unpredictable things). Use back() and -front() with caution, for example: -

-    TQValueVector<int> vec( 3 );
-    vec.push_back( 1 );
-    vec.push_back( 2 );
-    vec.push_back( 3 );
-    ...
-    if ( !vec.empty() ) {
-        // OK: modify the first element
-        int& i = vec.front();
-        i = 18;
-    }
-    ...
-    TQValueVector<double> dvec;
-    double d = dvec.back(); // undefined behavior
-
- -

Because TQValueVector manages memory dynamically, it is recommended -that you contruct a vector with an initial size. Inserting and -removing elements happens fastest when: -

-

By creating a TQValueVector with a sufficiently large initial size, -there will be less memory allocations. Do not use an initial size -that is too big, since it will still take time to construct all -the empty entries, and the extra space will be wasted if it is -never used. -

Because TQValueVector is value-based there is no need to be careful -about deleting elements in the vector. The vector holds its own -copies and will free them if the corresponding member or the -vector itself is deleted. You can force the vector to free all of -its items with clear(). -

TQValueVector is shared implicitly, which means it can be copied in -constant time. If multiple TQValueVector instances share the same -data and one needs to modify its contents, this modifying instance -makes a copy and modifies its private copy; it thus does not -affect the other instances. This is often called "copy on write". -If a TQValueVector is being used in a multi-threaded program, you -must protect all access to the vector. See TQMutex. -

There are several ways to insert elements into the vector. The -push_back() function insert elements into the end of the vector, -and is usually fastest. The insert() function can be used to add -elements at specific positions within the vector. -

Items can be also be removed from the vector in several ways. -There are several variants of the erase() function which removes a -specific element, or range of elements, from the vector. -

Vectors can be also sorted with various STL algorithms , or it can -be sorted using the TQt Template Library. -For example with qHeapSort(): -

Example: -

-    TQValueVector<int> v( 4 );
-    v.push_back( 5 );
-    v.push_back( 8 );
-    v.push_back( 3 );
-    v.push_back( 4 );
-    qHeapSort( v );
-
- -

TQValueVector stores its elements in contiguous memory. This means -that you can use a TQValueVector in any situation that requires an -array. -

See also TQt Template Library Classes, Implicitly and Explicitly Shared Classes, and Non-GUI Classes. - -

Member Type Documentation

-

TQValueVector::ConstIterator

-The vector's const iterator type. -

TQValueVector::Iterator

-The vector's iterator type. -

TQValueVector::ValueType

-The type of the object stored in the vector. -

TQValueVector::const_iterator

-The vector's const iterator type. -

TQValueVector::const_pointer

-The const pointer to T type. -

TQValueVector::const_reference

-The const reference to T type. -

TQValueVector::difference_type

-A signed integral type used to represent the distance between two iterators. -

TQValueVector::iterator

-The vector's iterator type. -

TQValueVector::pointer

-The pointer to T type. -

TQValueVector::reference

-The reference to T type. -

TQValueVector::size_type

-An unsigned integral type, used to represent various sizes. -

TQValueVector::value_type

-The type of the object stored in the vector. -

Member Function Documentation

-

TQValueVector::TQValueVector () -

- -

Constructs an empty vector without any elements. To create a -vector which reserves an initial amount of space for elements, use -TQValueVector(size_type n). - -

TQValueVector::TQValueVector ( const TQValueVector<T> & v ) -

- -

Constructs a copy of v. -

This operation costs O(1) time because TQValueVector is implicitly shared. -

The first modification to the vector does takes O(n) time, because -the elements must be copied. - -

TQValueVector::TQValueVector ( size_type n, const T & val = T ( ) ) -

- -

Constructs a vector with an initial size of n elements. Each -element is initialized with the value of val. - -

TQValueVector::TQValueVector ( std::vector<T> & v ) -

- -

Constructs a copy of v. - -

TQValueVector::TQValueVector ( const std::vector<T> & v ) -

- -

This operation costs O(n) time because v is copied. - -

TQValueVector::~TQValueVector () -

- -

Destroys the vector, destroying all elements and freeing the -allocated memory. References to the values in the vector and all -iterators of this vector become invalidated. Note that it is -impossible for an iterator to check whether or not it is valid: -TQValueVector is tuned for performance, not for error checking. - -

void TQValueVector::append ( const T & x ) -

- -

Appends a copy of x to the end of the vector. -

See also push_back() and insert(). - -

reference TQValueVector::at ( size_type i, bool * ok = 0 ) -

- -

Returns a reference to the element with index i. If ok is -non-null, and the index i is out of range, *ok is set to -FALSE and the returned reference is undefined. If the index i -is within the range of the vector, and ok is non-null, *ok -is set to TRUE and the returned reference is well defined. - -

const_reference TQValueVector::at ( size_type i, bool * ok = 0 ) const -

- -

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

Returns a const reference to the element with index i. If ok -is non-null, and the index i is out of range, *ok is set to -FALSE and the returned reference is undefined. If the index i -is within the range of the vector, and ok is non-null, *ok -is set to TRUE and the returned reference is well defined. - -

reference TQValueVector::back () -

- -

Returns a reference to the last element in the vector. If there is -no last element, this function has undefined behavior. -

See also empty() and front(). - -

const_reference TQValueVector::back () const -

- -

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

Returns a const reference to the last element in the vector. If -there is no last element, this function has undefined behavior. -

See also empty() and front(). - -

iterator TQValueVector::begin () -

- -

Returns an iterator pointing to the beginning of the vector. If -the vector is empty(), the returned iterator will equal end(). - -

const_iterator TQValueVector::begin () const -

- -

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

Returns a const iterator pointing to the beginning of the vector. -If the vector is empty(), the returned iterator will equal end(). - -

size_type TQValueVector::capacity () const -

- -

Returns the maximum number of elements that can be stored in the -vector without forcing memory reallocation. If memory reallocation -takes place, some or all iterators may become invalidated. - -

void TQValueVector::clear () -

- -

Removes all the elements from the vector. - -

const_iterator TQValueVector::constBegin () const -

- -

Returns a const iterator pointing to the beginning of the vector. -If the vector is empty(), the returned iterator will equal end(). -

See also constEnd(). - -

const_iterator TQValueVector::constEnd () const -

- -

Returns a const iterator pointing behind the last element of the -vector. -

See also constBegin(). - -

size_type TQValueVector::count () const -

- -

Returns the number of items in the vector. -

See also isEmpty(). - -

bool TQValueVector::empty () const -

- -

Returns TRUE if the vector is empty; otherwise returns FALSE. -Equivalent to size()==0, only faster. -

This function is provided for STL compatibility. It is equivalent -to isEmpty(). -

See also size(). - -

iterator TQValueVector::end () -

- -

Returns an iterator pointing behind the last element of the -vector. - -

const_iterator TQValueVector::end () const -

- -

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

Returns a const iterator pointing behind the last element of the -vector. - -

iterator TQValueVector::erase ( iterator pos ) -

- -

Removes the element at position pos and returns the position of -the next element. - -

iterator TQValueVector::erase ( iterator first, iterator last ) -

- -

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

Removes all elements from first up to but not including last -and returns the position of the next element. - -

reference TQValueVector::first () -

- -

Returns a reference to the first item in the vector. If there is -no first item, this function has undefined behavior. -

See also empty() and last(). - -

const_reference TQValueVector::first () const -

- -

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

-

reference TQValueVector::front () -

- -

Returns a reference to the first element in the vector. If there -is no first element, this function has undefined behavior. -

See also empty() and back(). - -

const_reference TQValueVector::front () const -

- -

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

Returns a const reference to the first element in the vector. If -there is no first element, this function has undefined behavior. -

See also empty() and back(). - -

iterator TQValueVector::insert ( iterator pos, const T & x ) -

- -

Inserts a copy of x at the position immediately before pos. -

See also push_back(). - -

iterator TQValueVector::insert ( iterator pos, size_type n, const T & x ) -

- -

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

Inserts n copies of x immediately before position x. -

See also push_back(). - -

bool TQValueVector::isEmpty () const -

- -

Returns TRUE if the vector is empty; returns FALSE otherwise. -

See also count(). - -

reference TQValueVector::last () -

- -

Returns a reference to the last item in the vector. If there is no -last item, this function has undefined behavior. -

See also empty() and first(). - -

const_reference TQValueVector::last () const -

- -

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

-

TQValueVector<T> & TQValueVector::operator= ( const TQValueVector<T> & v ) -

- -

Assigns v to this vector and returns a reference to this vector. -

All iterators of the current vector become invalidated by this -operation. The cost of such an assignment is O(1) since -TQValueVector is implicitly shared. - -

TQValueVector<T> & TQValueVector::operator= ( const std::vector<T> & v ) -

- -

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

Assigns v to this vector and returns a reference to this vector. -

All iterators of the current vector become invalidated by this -operation. The cost of this assignment is O(n) since v is -copied. - -

bool TQValueVector::operator== ( const TQValueVector<T> & x ) const -

- -

Returns TRUE if each element in this vector equals each -corresponding element in x; otherwise returns FALSE. - -

bool TQValueVector::operator== ( const TQValueVector<T> & x ) -

- -

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

Returns TRUE if each element in this vector equals each -corresponding element in x; otherwise returns FALSE. - -

reference TQValueVector::operator[] ( size_type i ) -

- -

Returns a reference to the element at index i. If i is out -of range, this function has undefined behavior. -

See also at(). - -

const_reference TQValueVector::operator[] ( size_type i ) const -

- -

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

Returns a const reference to the element at index i. If i is -out of range, this function has undefined behavior. -

See also at(). - -

void TQValueVector::pop_back () -

- -

Removes the last item from the vector. -

This function is provided for STL compatibility. - -

void TQValueVector::push_back ( const T & x ) -

- -

Appends a copy of x to the end of the vector. This is the -fastest way to add new elements. -

This function is provided for STL compatibility. It is equivalent -to append(). -

See also insert(). - -

void TQValueVector::reserve ( size_type n ) -

- -

Increases the vector's capacity. If n is less than or equal to -capacity(), nothing happens. Otherwise, additional memory is -allocated so that capacity() will be increased to a value greater -than or equal to n. All iterators will then become invalidated. -Note that the vector's size() and the values of existing elements -remain unchanged. - -

void TQValueVector::resize ( size_type n, const T & val = T ( ) ) -

- -

Changes the size of the vector to n. If n is greater than -the current size(), elements are added to the end and initialized -with the value of val. If n is less than size(), elements -are removed from the end. If n is equal to size() nothing -happens. - -

size_type TQValueVector::size () const -

- -

Returns the number of elements in the vector. -

This function is provided for STL compatibility. It is equivalent -to count(). -

See also empty(). - - -

-This file is part of the TQt toolkit. -Copyright © 1995-2007 -Trolltech. All Rights Reserved.

- -
Copyright © 2007 -TrolltechTrademarks -
TQt 3.3.8
-
- -- cgit v1.2.1