Sounds like what you want is set intersection. If your containers are ordered then std::set_intersection can give you the basic building block to do 2, although you could extend it more optimally to 3 or more sets if performance is important. And there is plenty of information online about implementing set operations. With ordered sets you can do the intersection and several other operations with N sets in a single pass.

If your containers are unordered, then there isn't really a good general solution without multiple passes. You could optimise it a bit (e.g. sorting the sets themselves so the shortest is first), but probably either an ordered container or a hash set would be the way to go depending on the values.

Otherwise the thing to look at is just putting your sets themselves in another container. A nested vector here might copy data you don't need to, but you could store a pointer to each vector or similar to avoid copies.

// the unoptimal approach
bool contains(const std::vector<int> &container, int val)
{
    for (auto &i : container)
        if (i == val)
            return true;
    return false;
}
std::vector<int> unordered_set_intersection(const std::vector<std::vector<int>> &sets)
{
    std::vector<int> out;
    for (auto x : sets.front())
    {
        bool all = true;
        for (auto it = sets.begin() + 1; it != sets.end(); ++it) // except first set
        {
            if (!contains(*it, x))
            {
                all = false;
                break;
            }
        }
        if (all) out.push_back(x);
    }
    return out;
}

If the vectors are not sorted but the elements are all in the range 0..63, you can generate a bitmask of which elements occur in which vector fairly quickly. Perform bitwise ‘and’ on the bitmasks for each vector to get a single bitmask, then iterate over just one of the vectors but skip the elements where the corresponding bit in the bitmask is not set.

If the vectors are sorted, there's a fairly obvious way to do this by stepping through all vectors at once. Point iterators to the beginning of all vectors. So long as not all iterators point to the same element, find which iterator(s) point to the largest element, then increment all others. Stop when one vector is exhausted or all iterators point to the same element. If all iterators point to the same element, process that element, then increment all iterators.

If the vectors are not sorted and the values are too big to make a bitmask practical, your best bet is to sort the vectors first.

If it is ordered common algorithms will work to do it in a single pass, and will work for numbers, strings, whatever datatype, . So I think you are overthinking it.

std::set_intersection does it for 2, and intersection(a, intersection(b, intersection(c, d)) etc. is mathematically the same as some intersection(a, b, c, d), so if performance is not a great concern just use that. Or implement the general case using multiple iterators.

A bitmask or another vector could be an optimisation in the unordered case I showed.

I had a similar problem in C# and the solution was to use a dictionary of type

Dictionary<Key, int>

and iterating over the first list and storing all it's keys into it. Then iterate over the second list and see if the key is present. To get a list of intersection elements, just iterate over the dictionary and find those elements which have a number value of equal to the number of lists you want to compare.

In C++ this can be solved the same, using some kind of hash container data structure like map/unordered_map and to minimize memory allocations, initialize it with a capacity that matches the vector with the smallest amount of elements