includes

Verifica se un intervallo ordinato contiene tutti gli elementi contenuti in un secondo intervallo ordinato, in cui il modello di equivalenza ordinamento o tra elementi può essere specificato da un predicato 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 
   );

Parametri

• _First1
  Un iteratore di input destinato alla posizione del primo elemento in prima di due ordinati gli intervalli di origine da verificare se tutti gli elementi del secondo contenuti nel primo.

• _Last1
  Un iteratore di input destinato alla posizione una dopo l'ultimo elemento in prima di due ordinati gli intervalli di origine da verificare se tutti gli elementi del secondo contenuti nel primo.

• _First2
  Un iteratore di input destinato alla posizione del primo elemento in una seconda di due intervalli di origine ordinati consecutivi da verificare se tutti gli elementi del secondo contenuti nel primo.

• _Last2
  Un iteratore di input destinato alla posizione una dopo l'ultimo elemento di un seconda di due intervalli di origine ordinati consecutivi da verificare se tutti gli elementi del secondo contenuti nel primo.

• _Comp
  Oggetto funzione predicativa definito dall'utente che definisce in che modo un elemento è minore di un altro. Un predicato binario accetta due argomenti e restituisce true se la condizione è soddisfatta e false se non è soddisfatta.

Valore restituito

true se l'intervallo innanzitutto ordinato contiene tutti gli elementi del secondo intervallo ordinato; in caso contrario, false.

Note

È possibile considerare a questo test è che abbia determinato se il secondo intervallo di origine è un sottoinsieme del primo intervallo di origine.

Gli intervalli di origine ordinati fatto riferimento siano validi; tutti i puntatori devono essere dereferenceable e, all'interno di ogni sequenza, l'ultima posizione sia raggiungibile da prima dall'aumento.

Gli intervalli di origine ordinati devono entrambi essere disposti in una precondizione all'applicazione dell'algoritmo include conformemente allo stesso ordine di è possibile utilizzare dall'algoritmo per ordinare gli intervalli combinati.

Gli intervalli di origine non vengono modificati dall'algoritmo merge.

I tipi di valore degli iteratori di input deve essere minore di. confrontabile essere ordinatoe, in modo che, dato due elementi, può essere determinato uno che sono equivalenti nel senso che non è inferiore all'altro) o che uno è inferiore all'altro. Ciò comporta un ordinamento tra elementi non equivalenti. Più precisamente, l'algoritmo verifica se tutti gli elementi dell'intervallo innanzitutto ordinato in un binario predicato specificato in ordine equivalente a quelli del secondo intervallo ordinato.

La complessità dell'algoritmo è lineare con il massimo 2 * ((_Last1 - _First1) - (_Last2 - _First2)) - 1 confronti per intervalli di origine vuoto.

Esempio

// 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;
}

Requisiti

Intestazione: <algoritmo>

Spazio dei nomi: std

Vedere anche

Riferimenti

includes (Esempi della libreria di modelli standard)

Versione con predicato di includes

Libreria di modelli standard