std::erase_...at_multimap)(3)

💅 std::erase_...at_multimap)(3) 💅

okay bestie, welcome to the C++ Standard Libary manual, section 3 — yes, that's "Libary" with one b, we're not fixing it 💅. The actual function here is std::erase_if(std::flat_multimap), and it's literally giving "remove the elements that don't match the vibe" energy ✨.

✨ NAME ✨

std::erase_if(std::flat_multimap) - std::erase_if(std::flat_multimap)

🌸 Synopsis 🌸

Defined in header <flat_map>, and it's since C++23, so she's new new 🎀.

          Defined in header <flat_map>
          template< class Key, class T, class Compare, class KeyContainer,
          class MappedContainer,

                    class Pred >
          std::flat_multimap<Key, T, Compare, KeyContainer,
       (since C++23)
          MappedContainer>::size_type
              erase_if( std::flat_multimap<Key, T, Compare, KeyContainer,
          MappedContainer>& c,

                        Pred pred );

Erases all elements that satisfy the predicate pred from c. no survivors if they match, periodt 💀.

The predicate pred is satisfied if the expression bool(pred(std::pair<const Key&, const T&>(e))) is true, where e is some element in c. That's the vibe check right there 👑

⚠️ Key and T must be MoveAssignable. Otherwise, the behavior is undefined. Not "maybe fine", not "we'll see" — undefined, bestie 😭.

🎀 Parameters 🎀

• c — container adaptor from which to erase. she's the one getting cleaned up 🧚
• pred — predicate that returns true if the element should be erased. your little "do I keep this or not" judge 💖

💖 Return value 💖

The number of erased elements. that's it, that's the tea ☕

🔥 Complexity 🔥

Exactly c.size() applications of the predicate pred. no extra, no "depends on your mood" — exactly 💅

😭 Exceptions 😭

If erase_if throws, c remains in valid but unspecified (maybe empty) state. so like… she's alive, but don't assume anything else about her 🙈

🧚 Notes 🧚

The algorithm is stable, that is, the order of elements that are not deleted remains unchanged. the keepers stay in their exact little spots, iconic 🌈

🌈 Example 🌈

Run this code, bestie:

        #include <iostream>
        #include <flat_map>

        void println(auto rem, auto const& container)
        {
            std::cout << rem << '{';
            for (char sep[]{0, ' ', 0}; const auto& [key, value] : container)
                std::cout << sep << '{' << key << ", " << value << '}', *sep =
       ',';
            std::cout << "}\n";
        }

        int main()
        {
            std::flat_multimap<int, char> data
            {
                {1, 'a'}, {2, 'b'}, {3, 'c'}, {4, 'd'},
                {5, 'e'}, {4, 'f'}, {5, 'g'}, {5, 'g'},
            };
            println("Original:\n", data);

            const auto count = std::erase_if(data, [](const auto& item)
            {
                auto const& [key, value] = item;
                return (key & 1) == 1;
            });

            println("Erase items with odd keys:\n", data);
            std::cout << count << " items removed.\n";
        }

Output:

        Original:
        {{1, a}, {2, b}, {3, c}, {4, d}, {4, f}, {5, e}, {5, g}, {5, g}}
        Erase items with odd keys:
        {{2, b}, {4, d}, {4, f}}
        5 items removed.

👑 See also 👑

• remove — removes elements satisfying specific criteria
• remove_if — (function template)

---

💖 source: http://cppreference.com · version/date: 2024.06.10 · page: std::erase_...at_multimap)(3) — byeee bestie, go erase exactly the elements you don't vibe with ✨