|< C++ STL Container 9 | Main | C++ STL Container 11 >|Site Index |Download |

MODULE 29b

THE C++ STL CONTAINER PART 10

map, multimap, hash_map, hash_multimap, hash_set,hash_multiset

Specialized Template Functions

Classes

hash_set Template Class Members

Typedefs

hash_set Template Class Member Functions

hash_set Class

• The container class hash_set is an extension of the Standard Template Library (STL) and is used for the storage and fast retrieval of data from a collection in which the values of the elements contained are unique and serve as the key values.

template <class Key, class Traits=hash_compare<Key, less<Key> >, class Allocator=allocator<Key> > 

Parameters

hash_set Constructor

• Constructs a hash_set that is empty or that is a copy of all or part of some other hash_set.

• All constructors store a type of allocator object that manages memory storage for the hash_set and that can later be returned by callingget_allocator().  The allocator parameter is often omitted in the class declarations and preprocessing macros used to substitute alternative allocators.

• All constructors initialize their hash_sets.

• All constructors store a function object of type Traits that is used to establish an order among the keys of the hash_set and that can later be returned by calling key_comp.

• The first three constructors specify an empty initial hash_set, the second specifying the type of comparison function (_Comp) to be used in establishing the order of the elements and the third explicitly specifying the allocator type (_Al) to be used.

• The key word explicit suppresses certain kinds of automatic type conversion.

• The fourth constructor specifies a copy of the hash_set_Right.

• The last three constructors copy the range [_First, _Last) of a hash_set with increasing explicitness in specifying the type of comparison function of class Traits andallocator.

• The actual order of elements in a hash_set container depends on the hash function, the ordering function and the current size of the hash table and cannot, in general, be predicted as it could with the set container, where it was determined by the ordering function alone.

// hash_set, constructor, compiled with VC7.0/.Net with some warnings

#include <hash_set>

#include <iostream>

using namespace std;

 

int main()

{

    hash_set <int>::iterator hst0_Iter, hst1_Iter, hst3_Iter, hst4_Iter, hst5_Iter;

    hash_set <int, hash_compare <int, greater<int> > >::iterator hst2_Iter;

    // create an empty hash_set hst0 of key type integer

    hash_set <int> hst0;

    // create an empty hash_set hst1 with the key comparison function of less than, then insert 5 elements

    hash_set <int, hash_compare<int, less<int> > > hst1;

    hst1.insert(7);

    hst1.insert(3);

    hst1.insert(12);

    hst1.insert(51);

    hst1.insert(10);

    // create an empty hash_set hst2 with the key comparison function of greater than, then insert 4 elements

    hash_set<int, hash_compare<int, greater<int> > > hst2;

    hst2.insert(71);

    hst2.insert(68);

    hst2.insert(68);

    hst2.insert(55);

    // create a hash_set hst3 with the hash_set hst1 allocator

    hash_set<int>::allocator_type hst1_Alloc;

    hst1_Alloc = hst1.get_allocator();

    hash_set<int> hst3(less<int>(),hst1_Alloc);

    hst3.insert(12);

    hst3.insert(13);

    hst3.insert(12);

    // create a hash_set hst4 by copying the range hst1[_First, _Last)

    hash_set <int>::const_iterator hst1_PIter, hst1_QIter;

    hst1_PIter = hst1.begin();

    hst1_QIter = hst1.begin();

    hst1_QIter++;

    hst1_QIter++;

    hash_set<int> hst4(hst1_PIter, hst1_QIter);

    // create a hash_set hst5 by copying the range hst4[_First, _Last) and with the allocator of hash_set hst2

    hash_set <int>::allocator_type hst2_Alloc;

    hst2_Alloc = hst2.get_allocator();

    hash_set <int> hst5(hst1.begin(), ++hst1.begin(), less<int>(), hst2_Alloc);

    // --------------------------------------------------------------

    cout<<"Operation: hash_set <int> hst0\n";

    cout<<"hst0 data: ";

    for(hst0_Iter = hst0.begin(); hst0_Iter != hst0.end(); hst0_Iter++)

        cout<<*hst0_Iter<<" ";

    cout<<endl;

    cout<<"\nOperation: hash_set <int, hash_compare<int, \nless<int> > > hst1\n";

    cout<<"Operation: hst1.insert(7)...\n";

    cout<< "hst1 data: ";

    for(hst1_Iter = hst1.begin(); hst1_Iter != hst1.end(); hst1_Iter++)

        cout<<*hst1_Iter << " ";

    cout<<endl;

    cout<<"\nOperation: hash_set <int, hash_compare<int, \ngreater<int> > > hst2\n";

    cout<<"Operation: hst2.insert(71)...\n";

    cout<<"hst2 data: ";

    for(hst2_Iter = hst2.begin(); hst2_Iter != hst2.end(); hst2_Iter++)

        cout<<*hst2_Iter<<" ";

    cout<<endl;

    cout<<"\nOperation: hash_set<int> hst3(less<int>(),hst1_Alloc)\n";

    cout<<"Operation: hst3.insert(12)...\n";

    cout<<"hst3 data: ";

    for(hst3_Iter = hst3.begin(); hst3_Iter != hst3.end(); hst3_Iter++)

        cout<<*hst3_Iter<<" ";

    cout<<endl;

    cout<<"\nOperation: hash_set<int> hst4(hst1_PIter, hst1_QIter)\n";

    cout<<"hst4 data: ";

    for(hst4_Iter = hst4.begin(); hst4_Iter != hst4.end(); hst4_Iter++)

        cout<<*hst4_Iter<<" ";

    cout<<endl;

    cout<<"\nOperation: hash_set <int> hst5(hst1.begin(), \n++hst1.begin(), less<int>(), hst2_Alloc)\n";

    cout<<"hst5 data: ";

    for(hst5_Iter = hst5.begin(); hst5_Iter != hst5.end(); hst5_Iter++)

        cout<<*hst5_Iter<<" ";

    cout<<endl;

    return 0;

}

 

Output:

---------------------------------------------End of the hash_set----------------------------------------

tenouk C++ STL tutorial

Further C++ STL container classes reading:

1. Source code is available inC++ STL Container source code.

2. Check thebest selling C / C++ and STL books at Amazon.com.

3. Acomplete C Standard Library.

4. Acomplete C++ Standard Library documentation that includes STL.

|< C++ STL Container 9 | Main | C++ STL Container 11 >|Site Index |Download |

C++ STL Container Classes:  Part 1 | Part 2 |Part 3 | Part 4 | Part 5 | Part 6 | Part 7 | Part 8 | Part 9 | Part 10 | Part 11