includes

Artículo
06/09/2015

Prueba si un intervalo ordenados contiene todos los elementos contenidos en un intervalo ordenados segundo, donde el orden o el criterio de equivalencia entre los elementos se pueden especificar mediante un predicado binario.

template<class InputIterator1, class InputIterator2> 
   bool includes( 
      InputIterator1 _First1,  
      InputIterator1 _Last1, 
      InputIterator2 _First2,  
      InputIterator2 _Last1 
   ); 
template<class InputIterator1, class InputIterator2, class BinaryPredicate> 
   bool includes( 
      InputIterator1 _First1,  
      InputIterator1 _Last1, 
      InputIterator2 _First2,  
      InputIterator2 _Last1,
      BinaryPredicate _Comp 
   );

Parámetros

_First1
Un iterador de entrada que las la posición del primer elemento de la primera de dos tamaños intervalos de origen que se van a comprobar para si todos los elementos de segundos contenidos en el primero.
_Last1
Un iterador de entrada que las la posición una más allá del último elemento de la primera de dos tamaños intervalos de origen que se van a comprobar para si todos los elementos de segundos contenidos en el primero.
_First2
Un iterador de entrada que dirige la posición del primer elemento de la segunda de dos intervalos de origen ordenados consecutivos que se van a comprobar para si todos los elementos de segundos contenidos en el primero.
_Last2
Un iterador de entrada que dirige la posición una más allá del último elemento de la segunda de dos intervalos de origen ordenados consecutivos que se van a comprobar para si todos los elementos de segundos contenidos en los primeros.
_Comp
Objeto de función de predicado definido por el usuario que define el sentido en el que un elemento es menor que otro. Un predicado binario acepta dos argumentos y devuelve true cuando se cumple y false cuando no se cumple.

Valor devuelto

true si el primer rango ordenados contiene todos los elementos del segundo intervalo ordenados; si no, false.

Comentarios

Otra manera de pensar en esta prueba es que determinaba si el intervalo de segundo origen es un subconjunto del primer intervalo de origen.

Los intervalos de origen ordenados hace referencia deben ser válidos; todos los punteros deben ser dereferenceable y, dentro de cada secuencia, la posición última debe ser accesible de primera por el aumento.

Los intervalos de origen ordenados deben cada organizarse mientras una condición previa a la aplicación del algoritmo incluye de acuerdo con el mismo de ordenación que es utilizar el algoritmo para ordenar los intervalos combinados.

Los intervalos de origen no son modificados por el algoritmo merge.

Los tipos de valor de iteradores de entrada es necesario menos- que comparable ser secuenciado, para, dadas dos elementos, poder determinar las que son equivalentes (en el sentido de que ninguno es menor que otro) o que uno es menor que otro. Esto produce una ordenación entre los elementos no equivalentes. Más concretamente, el algoritmo prueba si todos los elementos del primer rango ordenados en predicado binario especificado tienen equivalente de ordenación a los del segundo intervalo ordenados.

La complejidad del algoritmo es lineal con como máximo 2 * ((_Last1 – _First1) – (_Last2 – _First2)) – las comparaciones 1 para los intervalos de origen no vacíos.

Ejemplo

// alg_includes.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>      // For greater<int>( )
#include <iostream>

// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser (int elem1, int elem2 )
{
   if ( elem1 < 0 ) 
      elem1 = - elem1;
   if ( elem2 < 0 ) 
      elem2 = - elem2;
   return elem1 < elem2;
}

int main( )
{
   using namespace std;
   vector <int> v1a, v1b;
   vector <int>::iterator Iter1a,  Iter1b;

   // Constructing vectors v1a & v1b with default less-than ordering
   int i;
   for ( i = -2 ; i <= 4 ; i++ )
   {
      v1a.push_back(  i );
   }

   int ii;
   for ( ii =-2 ; ii <= 3 ; ii++ )
   {
      v1b.push_back(  ii  );
   }

   cout << "Original vector v1a with range sorted by the\n "
        << "binary predicate less than is v1a = ( " ;
   for ( Iter1a = v1a.begin( ) ; Iter1a != v1a.end( ) ; Iter1a++ )
      cout << *Iter1a << " ";
   cout << ")." << endl;

   cout << "Original vector v1b with range sorted by the\n "
        <<  "binary predicate less than is v1b = ( " ;
   for ( Iter1b = v1b.begin ( ) ; Iter1b != v1b.end ( ) ; Iter1b++ )
      cout << *Iter1b << " ";
   cout << ")." << endl;
   
   // Constructing vectors v2a & v2b with ranges sorted by greater
   vector <int> v2a ( v1a ) , v2b ( v1b );
   vector <int>::iterator Iter2a,  Iter2b;
   sort ( v2a.begin ( ) , v2a.end ( ) , greater<int> ( ) );
   sort ( v2b.begin ( ) , v2b.end ( ) , greater<int> ( ) );
   v2a.pop_back ( );

   cout << "Original vector v2a with range sorted by the\n "
        <<  "binary predicate greater is v2a = ( " ;
   for ( Iter2a = v2a.begin ( ) ; Iter2a != v2a.end ( ) ; Iter2a++ )
      cout << *Iter2a << " ";
   cout << ")." << endl;

   cout << "Original vector v2b with range sorted by the\n "
        <<  "binary predicate greater is v2b = ( " ;
   for ( Iter2b = v2b.begin ( ) ; Iter2b != v2b.end ( ) ; Iter2b++ )
      cout << *Iter2b << " ";
   cout << ")." << endl;

   // Constructing vectors v3a & v3b with ranges sorted by mod_lesser
   vector <int> v3a ( v1a ), v3b ( v1b ) ;
   vector <int>::iterator Iter3a, Iter3b;
   reverse (v3a.begin( ), v3a.end( ) );
   v3a.pop_back ( );
   v3a.pop_back ( );
   sort ( v3a.begin ( ) , v3a.end ( ) , mod_lesser );
   sort ( v3b.begin ( ) , v3b.end ( ) , mod_lesser );

   cout << "Original vector v3a with range sorted by the\n "
        <<  "binary predicate mod_lesser is v3a = ( " ;
   for ( Iter3a = v3a.begin ( ) ; Iter3a != v3a.end ( ) ; Iter3a++ )
      cout << *Iter3a << " ";
   cout << ")." << endl;

   cout << "Original vector v3b with range sorted by the\n "
        <<  "binary predicate mod_lesser is v3b = ( " ;
   for ( Iter3b = v3b.begin ( ) ; Iter3b != v3b.end ( ) ; Iter3b++ )
      cout << *Iter3b << " ";
   cout << ")." << endl;

   // To test for inclusion under an asscending order
   // with the default binary predicate less <int> ( )
   bool Result1;
   Result1 = includes ( v1a.begin ( ) , v1a.end ( ) ,
      v1b.begin ( ) , v1b.end ( ) );
   if ( Result1 )
      cout << "All the elements in vector v1b are "
           << "contained in vector v1a." << endl;
   else
      cout << "At least one of the elements in vector v1b "
           << "is not contained in vector v1a." << endl;

   // To test for inclusion under descending
   // order specify binary predicate greater<int>( )
   bool Result2;
   Result2 = includes ( v2a.begin ( ) , v2a.end ( ) ,
      v2b.begin ( ) , v2b.end ( ) , greater <int> ( ) );
   if ( Result2 )
      cout << "All the elements in vector v2b are "
           << "contained in vector v2a." << endl;
   else
      cout << "At least one of the elements in vector v2b "
           << "is not contained in vector v2a." << endl;

   // To test for inclusion under a user
   // defined binary predicate mod_lesser
   bool Result3;
   Result3 = includes ( v3a.begin ( ) , v3a.end ( ) ,
      v3b.begin ( ) , v3b.end ( ) , mod_lesser );
   if ( Result3 )
      cout << "All the elements in vector v3b are "
           << "contained under mod_lesser in vector v3a."
           << endl;
   else
      cout << "At least one of the elements in vector v3b is "
           << " not contained under mod_lesser in vector v3a." 
           << endl;
}