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

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

THE INFORMATION PROVIDED IN THE MICROSOFT KNOWLEDGE BASE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. MICROSOFT DISCLAIMS ALL WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL MICROSOFT CORPORATION OR ITS SUPPLIERS BE LIABLE FOR ANY DAMAGES WHATSOEVER INCLUDING DIRECT, INDIRECT, INCIDENTAL, CONSEQUENTIAL, LOSS OF BUSINESS PROFITS OR SPECIAL DAMAGES, EVEN IF MICROSOFT CORPORATION OR ITS SUPPLIERS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. SOME STATES DO NOT ALLOW THE EXCLUSION OR LIMITATION OF LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES SO THE FOREGOING LIMITATION MAY NOT APPLY.

Copyright Microsoft Corporation 1986-2002.