`<set>`, opérateurs

Article
10/12/2023

operator!= (set)

Teste si l’objet set situé à gauche de l’opérateur n’est pas égal à l’objet set situé à droite.

bool operator!=(const set <Key, Traits, Allocator>& left, const set <Key, Traits, Allocator>& right);

Paramètres

left
Objet de type set.

right
Objet de type set.

Valeur de retour

true si les jeux ne sont pas égaux ; false si les jeux sont égaux.

Notes

La comparaison entre les objets set est basée sur une comparaison par paire de leurs éléments. Deux objets set sont égaux s’ils ont le même nombre d’éléments et si leurs éléments respectifs ont les mêmes valeurs. Sinon, elles sont inégales.

Exemple

// set_op_ne.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1, s2, s3;
   int i;

   for ( i = 0 ; i < 3 ; i++ )
   {
      s1.insert ( i );
      s2.insert ( i * i );
      s3.insert ( i );
   }

   if ( s1 != s2 )
      cout << "The sets s1 and s2 are not equal." << endl;
   else
      cout << "The sets s1 and s2 are equal." << endl;

   if ( s1 != s3 )
      cout << "The sets s1 and s3 are not equal." << endl;
   else
      cout << "The sets s1 and s3 are equal." << endl;
}
/* Output:
The sets s1 and s2 are not equal.
The sets s1 and s3 are equal.
*/

`operator<` (set)

Teste si l’objet set situé à gauche de l’opérateur est inférieur à l’objet set situé à droite.

bool operator<(const set <Key, Traits, Allocator>& left, const set <Key, Traits, Allocator>& right);

Paramètres

left
Objet de type set.

right
Objet de type set.

Valeur de retour

true si l’ensemble situé à gauche de l’opérateur est strictement inférieur au jeu situé à droite de l’opérateur ; sinon false.

Notes

La comparaison entre les objets set est basée sur une comparaison par paire de leurs éléments. La relation d'infériorité entre deux objets est basée sur une comparaison de la première paire d'éléments inégaux.

Exemple

// set_op_lt.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1, s2, s3;
   int i;

   for ( i = 0 ; i < 3 ; i++ )
   {
      s1.insert ( i );
      s2.insert ( i * i );
      s3.insert ( i - 1 );
   }

   if ( s1 < s2 )
      cout << "The set s1 is less than the set s2." << endl;
   else
      cout << "The set s1 is not less than the set s2." << endl;

   if ( s1 < s3 )
      cout << "The set s1 is less than the set s3." << endl;
   else
      cout << "The set s1 is not less than the set s3." << endl;
}
/* Output:
The set s1 is less than the set s2.
The set s1 is not less than the set s3.
*/

`operator<=` (set)

Teste si l’objet set situé à gauche de l’opérateur est inférieur ou égal à l’objet set situé à droite.

bool operator!<=(const set <Key, Traits, Allocator>& left, const set <Key, Traits, Allocator>& right);

Paramètres

left
Objet de type set.

right
Objet de type set.

Valeur de retour

true si l’ensemble situé à gauche de l’opérateur est inférieur ou égal à l’ensemble situé à droite de l’opérateur ; sinon false.

Notes

La comparaison entre les objets set est basée sur une comparaison par paire de leurs éléments. La relation d'infériorité ou d'égalité entre deux objets est basée sur une comparaison de la première paire d'éléments inégaux.

Exemple

// set_op_le.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1, s2, s3, s4;
   int i;

   for ( i = 0 ; i < 3 ; i++ )
   {
      s1.insert ( i );
      s2.insert ( i * i );
      s3.insert ( i - 1 );
      s4.insert ( i );
   }

   if ( s1 <= s2 )
      cout << "Set s1 is less than or equal to the set s2." << endl;
   else
      cout << "The set s1 is greater than the set s2." << endl;

   if ( s1 <= s3 )
      cout << "Set s1 is less than or equal to the set s3." << endl;
   else
      cout << "The set s1 is greater than the set s3." << endl;

   if ( s1 <= s4 )
      cout << "Set s1 is less than or equal to the set s4." << endl;
   else
      cout << "The set s1 is greater than the set s4." << endl;
}

Set s1 is less than or equal to the set s2.
The set s1 is greater than the set s3.
Set s1 is less than or equal to the set s4.

operator== (set)

Teste si l’objet set situé à gauche de l’opérateur est égal à l’objet set situé à droite.

bool operator!==(const set <Key, Traits, Allocator>& left, const set <Key, Traits, Allocator>& right);

Paramètres

left
Objet de type set.

right
Objet de type set.

Valeur de retour

true si l’ensemble situé à gauche de l’opérateur est égal à l’ensemble situé à droite de l’opérateur ; sinon false.

Notes

Exemple

// set_op_eq.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1, s2, s3;
   int i;

   for ( i = 0 ; i < 3 ; i++ )
   {
      s1.insert ( i );
      s2.insert ( i * i );
      s3.insert ( i );
   }

   if ( s1 == s2 )
      cout << "The sets s1 and s2 are equal." << endl;
   else
      cout << "The sets s1 and s2 are not equal." << endl;

   if ( s1 == s3 )
      cout << "The sets s1 and s3 are equal." << endl;
   else
      cout << "The sets s1 and s3 are not equal." << endl;
}

The sets s1 and s2 are not equal.
The sets s1 and s3 are equal.

`operator>` (set)

Teste si l’objet set situé à gauche de l’opérateur est supérieur à l’objet set situé à droite.

bool operator>(const set <Key, Traits, Allocator>& left, const set <Key, Traits, Allocator>& right);

Paramètres

left
Objet de type set.

right
Objet de type set.

Valeur de retour

true si l’ensemble situé à gauche de l’opérateur est supérieur à l’ensemble situé à droite de l’opérateur ; sinon false.

Notes

La comparaison entre les objets set est basée sur une comparaison par paire de leurs éléments. La relation de supériorité entre deux objets est basée sur une comparaison de la première paire d'éléments inégaux.

Exemple

// set_op_gt.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1, s2, s3;
   int i;

   for ( i = 0 ; i < 3 ; i++ )
   {
      s1.insert ( i );
      s2.insert ( i * i );
      s3.insert ( i - 1 );
   }

   if ( s1 > s2 )
      cout << "The set s1 is greater than the set s2." << endl;
   else
      cout << "The set s1 is not greater than the set s2." << endl;

   if ( s1 > s3 )
      cout << "The set s1 is greater than the set s3." << endl;
   else
      cout << "The set s1 is not greater than the set s3." << endl;
}
/* Output:
The set s1 is not greater than the set s2.
The set s1 is greater than the set s3.
*/

`operator>=` (set)

Teste si l’objet set situé à gauche de l’opérateur est supérieur ou égal à l’objet set situé à droite.

bool operator!>=(const set <Key, Traits, Allocator>& left, const set <Key, Traits, Allocator>& right);

Paramètres

left
Objet de type set.

right
Objet de type set.

Valeur de retour

true si l’ensemble situé à gauche de l’opérateur est supérieur ou égal à l’ensemble situé à droite de la liste ; sinon false.

Notes

La comparaison entre les objets set est basée sur une comparaison par paire de leurs éléments. La relation de supériorité ou d'égalité entre deux objets est basée sur une comparaison de la première paire d'éléments inégaux.

Exemple

// set_op_ge.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1, s2, s3, s4;
   int i;

   for ( i = 0 ; i < 3 ; i++ )
   {
      s1.insert ( i );
      s2.insert ( i * i );
      s3.insert ( i - 1 );
      s4.insert ( i );
   }

   if ( s1 >= s2 )
      cout << "Set s1 is greater than or equal to set s2." << endl;
   else
      cout << "The set s1 is less than the set s2." << endl;

   if ( s1 >= s3 )
      cout << "Set s1 is greater than or equal to set s3." << endl;
   else
      cout << "The set s1 is less than the set s3." << endl;

   if ( s1 >= s4 )
      cout << "Set s1 is greater than or equal to set s4." << endl;
   else
      cout << "The set s1 is less than the set s4." << endl;
}

The set s1 is less than the set s2.
Set s1 is greater than or equal to set s3.
Set s1 is greater than or equal to set s4.

operator!= (multiset)

Teste si l’objet multiset situé à gauche de l’opérateur n’est pas égal à l’objet multiset situé à droite.

bool operator!=(const multiset <Key, Traits, Allocator>& left, const multiset <Key, Traits, Allocator>& right);

Paramètres

left
Objet de type multiset.

right
Objet de type multiset.

Valeur de retour

true si les jeux ou les multisets ne sont pas égaux ; false si les jeux ou les multisets sont égaux.

Notes

La comparaison entre les objets multiset est basée sur une comparaison par paire de leurs éléments. Deux objets multiset sont égaux s’ils ont le même nombre d’éléments et si leurs éléments respectifs ont les mêmes valeurs. Sinon, elles sont inégales.

Exemple

// multiset_op_ne.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> s1, s2, s3;
   int i;

   for ( i = 0 ; i < 3 ; i++ )
   {
      s1.insert ( i );
      s2.insert ( i * i );
      s3.insert ( i );
   }

   if ( s1 != s2 )
      cout << "The multisets s1 and s2 are not equal." << endl;
   else
      cout << "The multisets s1 and s2 are equal." << endl;

   if ( s1 != s3 )
      cout << "The multisets s1 and s3 are not equal." << endl;
   else
      cout << "The multisets s1 and s3 are equal." << endl;
}

The multisets s1 and s2 are not equal.
The multisets s1 and s3 are equal.

`operator<` (multiset)

Teste si l’objet multiset situé à gauche de l’opérateur est inférieur à l’objet multiset situé à droite.

bool operator<(const multiset <Key, Traits, Allocator>& left, const multiset <Key, Traits, Allocator>& right);

Paramètres

left
Objet de type multiset.

right
Objet de type multiset.

Valeur de retour

true si le multiset situé à gauche de l’opérateur est strictement inférieur au multiset situé à droite de l’opérateur ; sinon false.

Notes

La comparaison entre les objets multiset est basée sur une comparaison par paire de leurs éléments. La relation d'infériorité entre deux objets est basée sur une comparaison de la première paire d'éléments inégaux.

Exemple

// multiset_op_lt.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> s1, s2, s3;
   int i;

   for ( i = 0 ; i < 3 ; i++ )
   {
      s1.insert ( i );
      s2.insert ( i * i );
      s3.insert ( i - 1 );
   }

   if ( s1 < s2 )
      cout << "The multiset s1 is less than "
           << "the multiset s2." << endl;
   else
      cout << "The multiset s1 is not less than "
           << "the multiset s2." << endl;

   if ( s1 < s3 )
      cout << "The multiset s1 is less than "
           << "the multiset s3." << endl;
   else
      cout << "The multiset s1 is not less than "
           << "the multiset s3." << endl;
}

The multiset s1 is less than the multiset s2.
The multiset s1 is not less than the multiset s3.

`operator<=` (multiset)

Teste si l’objet multiset situé à gauche de l’opérateur est inférieur ou égal à l’objet multiset situé à droite.

bool operator!<=(const multiset <Key, Traits, Allocator>& left, const multiset <Key, Traits, Allocator>& right);

Paramètres

left
Objet de type multiset.

right
Objet de type multiset.

Valeur de retour

true si le multiset situé à gauche de l’opérateur est inférieur ou égal au multiset situé à droite de l’opérateur ; sinon false.

Notes

La comparaison entre les objets multiset est basée sur une comparaison par paire de leurs éléments. La relation d'infériorité ou d'égalité entre deux objets est basée sur une comparaison de la première paire d'éléments inégaux.

Exemple

// multiset_op_le.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> s1, s2, s3, s4;
   int i;

   for ( i = 0 ; i < 3 ; i++ )
   {
      s1.insert ( i );
      s2.insert ( i * i );
      s3.insert ( i - 1 );
      s4.insert ( i );
   }

   if ( s1 <= s2 )
      cout << "The multiset s1 is less than "
           << "or equal to the multiset s2." << endl;
   else
      cout << "The multiset s1 is greater than "
           << "the multiset s2." << endl;

   if ( s1 <= s3 )
      cout << "The multiset s1 is less than "
           << "or equal to the multiset s3." << endl;
   else
      cout << "The multiset s1 is greater than "
           << "the multiset s3." << endl;

   if ( s1 <= s4 )
      cout << "The multiset s1 is less than "
           << "or equal to the multiset s4." << endl;
   else
      cout << "The multiset s1 is greater than "
           << "the multiset s4." << endl;
}

The multiset s1 is less than or equal to the multiset s2.
The multiset s1 is greater than the multiset s3.
The multiset s1 is less than or equal to the multiset s4.

operator== (multiset)

Teste si l’objet multiset situé à gauche de l’opérateur est égal à l’objet multiset situé à droite.

bool operator!==(const multiset <Key, Traits, Allocator>& left, const multiset <Key, Traits, Allocator>& right);

Paramètres

left
Objet de type multiset.

right
Objet de type multiset.

Valeur de retour

true si le multiset situé à gauche de l’opérateur est égal au multiset situé à droite de l’opérateur ; sinon false.

Notes

Exemple

// multiset_op_eq.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> s1, s2, s3;
   int i;

   for ( i = 0 ; i < 3 ; i++ )
   {
      s1.insert ( i );
      s2.insert ( i * i );
      s3.insert ( i );
   }

   if ( s1 == s2 )
      cout << "The multisets s1 and s2 are equal." << endl;
   else
      cout << "The multisets s1 and s2 are not equal." << endl;

   if ( s1 == s3 )
      cout << "The multisets s1 and s3 are equal." << endl;
   else
      cout << "The multisets s1 and s3 are not equal." << endl;
}

The multisets s1 and s2 are not equal.
The multisets s1 and s3 are equal.

`operator>` (multiset)

Teste si l’objet multiset situé à gauche de l’opérateur est supérieur à l’objet multiset situé à droite.

bool operator>(const multiset <Key, Traits, Allocator>& left, const multiset <Key, Traits, Allocator>& right);

Paramètres

left
Objet de type multiset.

right
Objet de type multiset.

Valeur de retour

true si le multiset situé à gauche de l’opérateur est supérieur au multiset situé à droite de l’opérateur ; sinon false.

Notes

La comparaison entre les objets multiset est basée sur une comparaison par paire de leurs éléments. La relation de supériorité entre deux objets est basée sur une comparaison de la première paire d'éléments inégaux.

Exemple

// multiset_op_gt.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> s1, s2, s3;
   int i;

   for ( i = 0 ; i < 3 ; i++ )
   {
      s1.insert ( i );
      s2.insert ( i * i );
      s3.insert ( i - 1 );
   }

   if ( s1 > s2 )
      cout << "The multiset s1 is greater than "
           << "the multiset s2." << endl;
   else
      cout << "The multiset s1 is not greater "
           << "than the multiset s2." << endl;

   if ( s1 > s3 )
      cout << "The multiset s1 is greater than "
           << "the multiset s3." << endl;
   else
      cout << "The multiset s1 is not greater than "
           << "the multiset s3." << endl;
}

The multiset s1 is not greater than the multiset s2.
The multiset s1 is greater than the multiset s3.

`operator>=` (multiset)

Teste si l’objet multiset situé à gauche de l’opérateur est supérieur ou égal à l’objet multiset situé à droite.

bool operator!>=(const multiset <Key, Traits, Allocator>& left, const multiset <Key, Traits, Allocator>& right);

Paramètres

left
Objet de type multiset.

right
Objet de type multiset.

Valeur de retour

true si le multiset situé à gauche de l’opérateur est supérieur ou égal au multiset situé à droite de la liste ; sinon false.

Notes

La comparaison entre les objets multiset est basée sur une comparaison par paire de leurs éléments. La relation de supériorité ou d'égalité entre deux objets est basée sur une comparaison de la première paire d'éléments inégaux.

Exemple

// multiset_op_ge.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> s1, s2, s3, s4;
   int i;

   for ( i = 0 ; i < 3 ; i++ )
   {
      s1.insert ( i );
      s2.insert ( i * i );
      s3.insert ( i - 1 );
      s4.insert ( i );
   }

   if ( s1 >= s2 )
      cout << "The multiset s1 is greater than "
           << "or equal to the multiset s2." << endl;
   else
      cout << "The multiset s1 is less than "
           << "the multiset s2." << endl;

   if ( s1 >= s3 )
      cout << "The multiset s1 is greater than "
           << "or equal to the multiset s3." << endl;
   else
      cout << "The multiset s1 is less than "
           << "the multiset s3." << endl;

   if ( s1 >= s4 )
      cout << "The multiset s1 is greater than "
           << "or equal to the multiset s4." << endl;
   else
      cout << "The multiset s1 is less than "
           << "the multiset s4." << endl;
}

The multiset s1 is less than the multiset s2.
The multiset s1 is greater than or equal to the multiset s3.
The multiset s1 is greater than or equal to the multiset s4.

Partager via

<set>, opérateurs

operator!= (set)

Paramètres

Valeur de retour

Notes

Exemple

operator< (set)

Paramètres

Valeur de retour

Notes

Exemple

operator<= (set)

Paramètres

Valeur de retour

Notes

Exemple

operator== (set)

Paramètres

Valeur de retour

Notes

Exemple

operator> (set)

Paramètres

Valeur de retour

Notes

Exemple

operator>= (set)

Paramètres

Valeur de retour

Notes

Exemple

operator!= (multiset)

Paramètres

Valeur de retour

Notes

Exemple

operator< (multiset)

Paramètres

Valeur de retour

Notes

Exemple

operator<= (multiset)

Paramètres

Valeur de retour

Notes

Exemple

operator== (multiset)

Paramètres

Valeur de retour

Notes

Exemple

operator> (multiset)

Paramètres

Valeur de retour

Notes

Exemple

operator>= (multiset)

Paramètres

Valeur de retour

Notes

Exemple

Commentaires

Ressources supplémentaires

`<set>`, opérateurs

`operator<` (set)

`operator<=` (set)

`operator>` (set)

`operator>=` (set)

`operator<` (multiset)

`operator<=` (multiset)

`operator>` (multiset)

`operator>=` (multiset)