C++ Unordered_multimap::operator!= Function

---

---

The C++ std::unordered_multimap::operator!= function is used to check whether two unordered_multimaps are equal or not. if both unordered_multimap are not equal returns true otherwise false.

This function will work when the both the multimaps have the same data type, If we try to compare the unordered_multimaps with different data types, then it will displays an error.

Syntax

Following is the syntax of std::unordered_multimap::operator!= function.

bool operator!=(const unordered_multimap<Key,T,Hash,Pred,Alloc>& first,const unordered_multimap<Key,T,Hash,Pred,Alloc>& second);

Parameters

• first − First unordered_multimap object.
• second − Second unordered_multimap object.

Return value

This function returns true if both unordered_multimap are not equal otherwise false.

Example 1

In the following example, we are going to demonstrate the usage of unordered_multimap::operator!= function.

#include <iostream>
#include <unordered_map>
using namespace std;
int main(void) {
   unordered_multimap<char, int> umm1;
   unordered_multimap<char, int> umm2;
   umm1.emplace('a', 1);
   if (umm1 != umm2)
      cout << "Both unordered_multimaps are not equal" << endl;
   umm1 = umm2;
   if (!(umm1 != umm2))
      cout << "Both unordered_multimaps are equal" << endl;
   return 0;
}

Output

Let us compile and run the above program, this will produce the following result −

Both unordered_multimaps are not equal
Both unordered_multimaps are equal

Example 2

Let's look at the following example, where we are going to use the operator!=() function on the multimaps of the same type with different elements.

#include <iostream>
#include <unordered_map>
using namespace std;
int main(void) {
   unordered_multimap<int, int> umm1 = {{1, 5}, {2, 6}, {3, 7}, {4, 8}};
   unordered_multimap<int, int> umm2 = {{2, 4}, {3, 1}, {4, 2}, {5, 3}};
   if (umm1 != umm2)
      cout << "Both unordered_multimaps are not equal" << endl;
   if (!(umm1 != umm2))
      cout << "Both unordered_multimaps are equal" << endl;
   return 0;
}

Output

If we run the above code it will generate the following output −

Both unordered_multimaps are not equal

Example 3

Consider the following example, where we are going to use the operator!=() function to display the elements of multimaps if they are not equal, or else it will display elements on any multimap if they are equal.

#include <iostream>
#include <unordered_map>
using namespace std;
int main(void) {
   unordered_multimap<string, string> umm1 = {{"aman", "kumar"}, {"akash", "gupta"}, {"vivek", "verma"}, {"aman", "kumar"}};
   unordered_multimap<string, string> umm2 = {{"Sakshi", "Sharma"}, {"Alok", "Gupta"}, {"Sakshi", "Sharma"}, {"Akash", "Kumar"}};
   if (umm1 != umm2) {
      cout<<"elements of umm1"<<endl;
      for(auto & it: umm1){
         cout<<it.first<<" : "<<it.second<<endl;
      }
      cout<<endl;
      cout<<"elements of umm2"<<endl;
      for(auto & it: umm2){
         cout<<it.first<<" : "<<it.second<<endl;
      }
   }
   if (!(umm1 != umm2)){
      cout << " elements of both unordered_multimaps are equal" << endl;
      for(auto& it: umm1){
         cout<<it.first<<" : "<<it.second<<endl;
      }
   }
   return 0;
}

Output

Following is the output of the above code −

elements of umm1
vivek : verma
akash : gupta
aman : kumar
aman : kumar

elements of umm2
Akash : Kumar
Alok : Gupta
Sakshi : Sharma
Sakshi : Sharma

Example 4

Following is the example, where we are going to use the operator!=() function and displaying the output in boolean value.

#include <iostream>
#include <unordered_map>
using namespace std;
int main() {
   unordered_multimap<string, string> umm1 = {{"Aman", "kumar"}, {"akash", "gupta"}, {"Alok", "gupta"}, {"Aman", "yadav"}};
   unordered_multimap<string, string> umm2 = {{"Aman", "kumar"}, {"akash", "gupta"}, {"Alok", "gupta"}, {"Aman", "yadav"}};
   
   cout<<boolalpha;
   cout<<(umm1 != umm2)<<endl;
   cout<<(!(umm1 != umm2))<<endl;
   
   return 0;
}

Output

Output of the above code is as follows −

false
true