How can I compare and get non-Included values in two lists

I want to compare two lists(stl list) :

for examples, I have these two list.

std::list<int> list1;
list1.push_back(1);
list1.push_back(2);
list1.push_back(3);
list1.push_back(4);
list1.push_back(5);

std::list<int> list2;
list2.push_back(5);
list2.push_back(6);
list2.push_back(7);

then, if compared these, and Find not included values list in other list.

like:

list1.Compare(list2)
result => {1,2,3,4}

I know I made this problem using looping,

std::list<int> result;
for(std::list<int>::iterator list1iter = list1.begin(); list1iter != list1.end(); list1iter++)
{
    bool isInList = false;
    for(std::list<int>::iterator list2iter = list2.begin(); list2iter != list2.end(); list2iter++)
    {
       if(*list1iter == *list2iter)
       {
           isInList = true;
           break;
       }
    }
    if(!isInList)
       result.Add(*list1iter);
}

But this is the only options?

There are (of course) many different options. In C++ you would probabaly use something from the standard libray, and here especially from the algorithm library. Please see here. You would be especially interested in the "Set operations (on sorted ranges)".

A nice description with easy to understand graphics you may find here

An code example for a possible solution could be:

#include <iostream>
#include <algorithm>
#include <list>

int main() {
    
    std::list<int> list1{};
    list1.push_back(1);
    list1.push_back(2);
    list1.push_back(3);
    list1.push_back(4);
    list1.push_back(5);
    
    std::list<int> list2{};
    list2.push_back(5);
    list2.push_back(6);
    list2.push_back(7);
    
    std::list<int> result{};
    
    std::set_difference(list1.begin(),list1.end(), list2.begin(), list2.end(), std::back_inserter(result));
    
    for (const int i : result) std::cout << i << "\n";

    return 0;
}

Maybe you can get the idea on how it could be done.

There are many ways to do this. Your idea with a nested for loops is generally considered not an optimal solution since time complexity is O(N^2).

The algorithm can be improved if you had more constraints like if you know that lists are sorted beforehand.

You can use hash maps in order to find the elements from the first lists that are not found in the second one in a more efficient way.

The algorithm's complexity will be O(N) space and O(N) time and works in a generic case - no matter if lists are sorted or not.

The idea is to insert the second list into a hash set and then iterate over the first list to see what items are missing:

    std::list<int> result;
    std::unordered_set<int> hash(list2.begin(), list2.end());
    for(const auto el : list1)
        if(hash.find(el) == hash.end()) result.push_back(el);