Q156321: INFO: STL Sample for Predicate Version of adjacent_find Function

Article: Q156321
Product(s): Microsoft C Compiler
Version(s): winnt:
Operating System(s): 
Keyword(s): _IK
Last Modified: 07-MAY-2001

-------------------------------------------------------------------------------
The information in this article applies to:

- The Standard C++ Library, used with:
   - *EDITOR Please do not choose this product*Microsoft Visual C++ 32-bit Edition* use 241, 265, 225, version 4.2 
-------------------------------------------------------------------------------

SUMMARY
=======

The sample code below illustrates how to use the predicate version of
adjacent_find STL function in Visual C++.

MORE INFORMATION
================

Required Header
---------------

  <algorithm>
   

Prototype
---------

     template<class ForwardIterator, class BinaryPredicate> inline
        ForwardIterator adjacent_find(ForwardIterator first,
                                             ForwardIterator last,
                                             BinaryPredicate binary_pred) ;

NOTE: The class/parameter names in the prototype do not match the version in the
header file. Some have been modified to improve readability.

Description
-----------

The adjacent_find algorithm finds consecutive pairs of matching elements in a
sequence. adjacent_find returns an iterator referencing the first consecutive
matching element in the range [first, last), or last if there are no such
elements.

Comparison is done using the binary_pred function in this version of the
algorithm. The binary_pred function can be any user-defined function. You could
also use one of the binary function objects provided by STL.

Sample Code
-----------

  ////////////////////////////////////////////////////////////////////// 
  // 
  // Compile options needed: /GX
  // 
  // adfind.cpp : Illustrates how to use the predicate version of
  //              adjacent_find function.
  // 
  // Functions:
  // 
  //   adjacent_find  - Locate a consecutive sequence in a range.
  // 
  // Written by Kalindi Sanghrajka
  // of Microsoft Product Support Services,
  // Software Core Developer Support.
  // Copyright (c) 1996 Microsoft Corporation. All rights reserved.
  ////////////////////////////////////////////////////////////////////// 

  // disable warning C4786: symbol greater than 255 character,
  // okay to ignore
  #pragma warning(disable: 4786)

  #include <iostream>
  #include <algorithm>
  #include <functional>
  #include <string>
  #include <vector>
  using namespace std;

  void main()
  {
      const int VECTOR_SIZE = 5 ;

      // Define a template class vector of strings
      typedef vector<string, allocator<string> > StringVector ;

      //Define an iterator for template class vector of strings
      typedef StringVector::iterator StringVectorIt ;

      StringVector NamesVect(VECTOR_SIZE) ;   //vector containing names

      StringVectorIt location ;   // stores the position for the
                                   // first pair of matching
                                   // consecutive elements.

      StringVectorIt start, end, it ;

      // Initialize vector NamesVect
      NamesVect[0] = "Aladdin" ;
      NamesVect[1] = "Jasmine" ;
      NamesVect[2] = "Mickey" ;
      NamesVect[3] = "Minnie" ;
      NamesVect[4] = "Goofy" ;

      start = NamesVect.begin() ;   // location of first
                                    // element of NamesVect

      end = NamesVect.end() ;       // one past the location
                                    // last element of NamesVect

      // print content of NamesVect
      cout << "NamesVect { " ;
      for(it = start; it != end; it++)
          cout << *it << ", " ;
      cout << " }\n" << endl ;

      // Find the first name that is lexicographically greater
      // than the following name in the range [first, last + 1).
      // This version performs matching using binary predicate
      // function greater<string>
      location = adjacent_find(start, end, greater<string>()) ;

      // print the first pair of strings such that the first name is
      // lexicographically greater than the second.
      if (location != end)
          cout << "(" << *location << ", " << *(location + 1) << ")"
          << " the first pair of strings in NamesVect such that\n"
          << "the first name is lexicographically greater than"
          << "the second\n" << endl ;
      else
          cout << "No consecutive pair of strings found such that\n"
          << "the first name is lexicographically greater than "
          << "the second\n" << endl ;

  }

Program Output is:

NamesVect { Aladdin, Jasmine, Mickey, Minnie, Goofy, }

(Minnie, Goofy) the first pair of strings in NamesVect such that the first name
is lexicographically greater than the second

REFERENCES
==========

Visual C++ Books On Line: Visual C++ Books:C/C++:Standard C++ Library Reference.

Additional query words: STL adjacent_find kbdss

======================================================================
Keywords          : _IK 
Technology        : kbVCsearch kbAudDeveloper kbVCLibrary
Version           : winnt:
Issue type        : kbinfo

=============================================================================