Added and removed elements between two data structures of type std::unordered_map>

Question

What's the most efficient way to retrieve the added and removed elements between two structure of type:

using T = unordered_map<std::string, std::set<struct A>>;

I wrote this code.

Could you please advise?

#include <iostream>
#include <string>
#include <unordered_map>
#include <set>
#include <algorithm>
#include <ranges>

struct A {
    std::string name;
    std::string address;

    auto operator<=>(const A& other) const = default;
};

using T = std::unordered_map<std::string, std::set<A>>;

void extractChanges(const T& t1, const T& t2, T& added, T& removed) {
    for (const auto& [key, set_t2] : t2) {
        const auto it_t1 = t1.find(key);
        const std::set<A>& set_t1 = (it_t1 != t1.end()) ? it_t1->second : std::set<A>();

        std::set<A> added_set, removed_set;

        for (const auto& a : set_t2) {
            if (set_t1.find(a) == set_t1.end())
                added_set.insert(a);
        }

        for (const auto& a : set_t1) {
            if (set_t2.find(a) == set_t2.end())
                removed_set.insert(a);
        }

        if (!added_set.empty())
            added.emplace(key, std::move(added_set));
        if (!removed_set.empty())
            removed.emplace(key, std::move(removed_set));
    }
}

int main() {
    T t1 = {
        {"key1", {{"name1", "address1"}, {"name2", "address2"}}},
        {"key2", {{"name3", "address3"}}}
    };

    T t2 = {
        {"key1", {{"name1", "address1"}, {"name2", "address2_modified"}}},
        {"key3", {{"name4", "address4"}}}
    };

    T added, removed;
    extractChanges(t1, t2, added, removed);
    return 0;
}

I want to retrieve the added and removed elements given t1 as reference and t1 as update/change.

This code handles all cases even the differences in inner sets. Is there a more efficient way to write this?

how did you end up with two somewhat similar containers? More efficient could be to keep track of modifications while they are applied — 463035818_is_not_an_ai, Aug 22 '23 at 12:24
Thank you for your help, I tried to use multimap/unordered_multimap but I had issues with duplications. I didn't modify t1 and t2. I didn't understand what you meant — Peter, Aug 22 '23 at 12:31
ok. Is it always a `std::unordered_map>;` ? Your title is too generic and broad. — 463035818_is_not_an_ai, Aug 22 '23 at 12:33
The two loops inserting into `added_set` and `removed_set` could be replaced with two calls to [`std::set_difference`](https://en.cppreference.com/w/cpp/algorithm/set_difference). It's `O(n)` while your loops are `O(n log n)` — Igor Tandetnik, Aug 22 '23 at 14:04
`const std::set& set_t1 = (it_t1 != t1.end()) ? it_t1->second : std::set ();` I'm reasonably sure this makes a copy of `it_t1->second`. Like any expression, the ternary operator produces an lvalue or an rvalue - it can't be an lvalue sometimes and an rvalue other times. So when you have an lvalue on one branch and a temporary on another, it has to copy-construct a temporary on the first branch, so as to produce an rvalue both ways. You are trying to be clever in the case the key is not found, but it's actually a pessimization. You may want to instead handle this case explicitly. — Igor Tandetnik, Aug 22 '23 at 14:09
Is `extractChanges` meant to be asymmetric? It reports keys found in `t2` but not `t1`, but doesn't report keys found in `t1` but not `t2`. In your example, it will not say that `"key2"` is removed. — Igor Tandetnik, Aug 22 '23 at 14:12
@IgorTandetnik, thanks for your response. Yes, after testing I found that the algorithm is not working as expected ! — Peter, Aug 22 '23 at 14:36
You have to at least describe what you want to do and what your expected result is, it's hard to guess what you really want to do just by looking at the code. — 康桓瑋, Aug 22 '23 at 14:50
I want to retrieve the added and removed elements given t1 as reference and t1 as update/change — Peter, Aug 22 '23 at 14:53

Added and removed elements between two data structures of type std::unordered_map>

0 Answers0