**Module:** Essential Tools Module **Group:** Generic

RWGSortedVector(val)RWGVector(val)

#include <rw/gsortvec.h> declare(RWGSortedVector,val) implement(RWGSortedVector, val) RWGSortedVector(val) v; // A sorted vector ofvals.

Class ** RWGSortedVector(val)** represents a vector of elements of val

NOTE -- RWGSortedVector is deprecated. Please use RWTValSortedVector or RWTPtrSortedVector.

Note that it is a *value-based* collection: items are copied in and out of the collection.

The class ** val** must have:

a default constructor;

well-defined copy semantics (

`val::val(const val&)`or equivalent);well-defined assignment semantics (

`val::operator=(const val&)`or equivalent);well-defined equality semantics (

`val::operator==(const val&``)`or equivalent);well-defined less-than semantics (

`val::operator<(const val&)`or equivalent).

To use this class you must declare and implement its base class as well as the class itself. For example, here is how you declare and implement a sorted collection of doubles:

declare(RWGVector,double) // Declare base class declare(RWGSortedVector,double) // Declare sorted vector // In one and only one .cpp file you must put the following: implement(RWGVector,double) // Implement base class implement(RWGSortedVector,double) // Implement sorted vector

For each ** val** of

Insertions and retrievals are done using a binary search. Note that the constructor of an ** RWGSortedVector(val)** requires a pointer to a "comparison function." This function should have protoval:

intcomparisonFunction(constval* a, constval* b);

and should return an `int` less than, greater than, or equal to zero, depending on whether the item pointed to by `a` is less than, greater than, or equal to the item pointed to by `b`. Candidates from the collection will appear as `a`, the key as `b`.

None

Here's an example of a sorted vector of `int`s:

#include <rw/gsortvec.h> #include <rw/rstream.h> declare(RWGVector,int) declare(RWGSortedVector,int) implement(RWGVector,int) implement(RWGSortedVector,int) // Declare and define the "comparison function": int compFun(const int* a, const int* b) { return *a - *b; } int main() { // Declare and define an instance, // using the comparison function 'compFun': RWGSortedVector(int) avec(compFun); // Do some insertions: avec.insert(3); // 3 avec.insert(17); // 3 17 avec.insert(5); // 3 5 17 std::cout << avec(1) << std::endl; // Prints '5' std::cout << avec.index(17) << std::endl; // Prints '2' return 0; }

RWGSortedVector(val)( int (*f)(const val*, const val*) );

Constructs a sorted vector of elements of val `val`, using the comparison function pointed to by `f`. The initial capacity of the vector will be set by the value `RWDEFAULT_CAPACITY`. The capacity will automatically be increased should too many items be inserted.

RWGSortedVector(val)(int (*f)(const val*, const val*), size_t N);

Constructs a sorted vector of elements of val `val`, using the comparison function pointed to by `f`. The initial capacity of the vector is `N`. The capacity is automatically increased if too many items are inserted.

valoperator()(size_t i) const;

Returns the `i`th value in the vector. The index `i` must be between `0` and the length of the vector less one. No bounds checking is performed.

valoperator[](size_t i) const;

Returns the `i`th value in the vector. The index `i` must be between `0` and the length of the vector less one. Bounds checking is performed.

size_tentries() const;

Returns the number of items currently in the collection.

size_tindex(val v);

Returns the index of the item with value `v`. The value "`RW_NPOS`" is returned if the value does not occur in the vector. A binary search, using the comparison function, is done to find the value. If duplicates are present, the index of the first instance is returned.

RWBooleaninsert(val v);

Inserts the new value `v` into the vector. A binary search, using the comparison function, is performed to determine where to insert the value. The item will be inserted after any duplicates. If the insertion causes the vector to exceed its capacity, it will automatically be resized by an amount given by `RWDEFAULT_RESIZE`.

voidremoveAt(size_t indx);

Removes the item at position `indx` from the collection. The value of `indx` must be between zero and the length of the collection less one. No bounds checking is performed. Old items from index `indx+1` will be shifted to lower indices. For example, the item at index `indx+1` will be moved to position `indx`, etc.

voidresize(size_t newCapacity);

Changes the capacity of the collection to `newCapacity`, which must be at least as large as the present number of items in the collection. Note that the actual number of items in the collection does not change, just the capacity.

©2004 Copyright Quovadx, Inc. All Rights Reserved.

Rogue Wave and SourcePro are registered trademarks of Quovadx, Inc. in the United States and other countries. All other trademarks are the property of their respective owners.

Contact Rogue Wave about documentation or support issues.