Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

includes

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
   );

_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.

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

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.

// 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;
}
Vector original v1a con el intervalo ordenados por
 predicado binario menos que v1a = (-2 -1 0 1 2 3 4).
Vector original v1b con el intervalo ordenados por
 predicado binario menos que v1b = (-2 -1 0 1 2 3).
Vector original v2a con el intervalo ordenados por
 el predicado binario mayor es v2a = (4 3 2 1 0 -1).
Vector original v2b con el intervalo ordenados por
 el predicado binario mayor es v2b = (3 2 1 0 -1 -2).
Vector original v3a con el intervalo ordenados por
 el mod_lesser binario de predicado es v3a = (0 1 2 3 4).
Vector original v3b con el intervalo ordenados por
 el mod_lesser binario de predicado es v3b = (0 -1 1 -2 2 3).
Todos los elementos del vector v1b están contenidos en el vector v1a.
Al menos uno de los elementos del vector v2b no están contenidos en el vector v2a.
Al menos uno de los elementos del vector v3b no se contiene en mod_lesser en el vector v3a.

Encabezado: <algorithm>

Espacio de nombres: std

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft