Implement multi-dimensional std::map with std::tuple and view access

Question

I know that I can create a multi-dimensional map by nesting maps together, e.g.:

// Two-dimensional key
map<string, map<int, double> > m;

so it is easy to extract all of the values associated to the highest order key. So if I have a set of data that looks like this:

A1 : 23.0
A2 : 45.3
A5 : 5.88
B9 : 7.2
B10 : 79.74

I could store it as std::map<std::string, std::map<uint, float>> mymap and easily retrieve all of the A values by doing mymap["A"].

I also know I can create a std::map with multiple keys by using a std::tuple, which is more intuitive: std::map<std::tuple<std::string,uint>, float> mymap

but is there a c++14 way to get all of the A elements with this second implementation?

you can use `lower_bound` or alike. – apple apple Aug 19 '22 at 15:15 — apple apple, Aug 19 '22 at 15:15

Ted Lyngmo · Answer 1 · 2022-08-19T15:59:11.823

2

std::map<std::tuple<std::string,uint>, float> mymap

^{I'm assuming uint means unsigned int.}

For this particular case, map::lower_bound and map::upper_bound may be combined:

auto beg = mymap.lower_bound({"A",0});
auto end = mymap.upper_bound({"A", static_cast<unsigned>(-1)});

for(auto it = beg; it != end; ++it) {
    std::cout << it->second << '\n'; // only "A" records
}

lower_bound will return an iterator to the first element not less than the given key, which is the first possible valid A entry, {"A", 0}.
upper_bound will return an iterator to the first element greater than the given key, which is the last possible valid A entry, {"A", (unsigned) -1}.

edited Aug 19 '22 at 15:59

answered Aug 19 '22 at 15:20

Ted Lyngmo

93,841
5
60
108

`map::equal_range` could also be used – Aykhan Hagverdili Aug 19 '22 at 15:24
1

@AyxanHaqverdili `equal_range` uses the built in comparator, so you can't specify just give me al `"A"`s without building a custom transparent comparator for the map. – NathanOliver Aug 19 '22 at 15:27
@NathanOliver And? It's not difficult to make one https://godbolt.org/z/djsGb4eeK – Aykhan Hagverdili Aug 19 '22 at 18:39

score 2 · Answer 2 · answered Aug 19 '22 at 18:43

You can use std::map::equal_range. It requires you to provide a transparent comparator, which is easy to make:

#include <cstdio>
#include <map>
#include <string>
#include <utility>

using Key = std::pair<std::string, int>;

struct Cmp {
    bool operator()(Key const& e1, std::string const& e2) const noexcept {
        return e1.first < e2;
    }

    bool operator()(std::string const& e1, Key const& e2) const noexcept {
        return e1 < e2.first;
    }

    bool operator()(Key const& e1, Key const& e2) const noexcept {
        return e1 < e2;
    }

    using is_transparent = bool;
};

int main() {
    std::map<Key, float, Cmp> map;

    map.insert({{"A", 1}, 23.0F});
    map.insert({{"A", 2}, 45.3F});
    map.insert({{"A", 5}, 5.88F});
    map.insert({{"B", 9}, 7.20F});
    map.insert({{"B", 10}, 79.74F});

    auto const rng = map.equal_range("A");
    for (auto it = rng.first; it != rng.second; ++it) {
        std::printf("%s%d : %.2f\n", 
                    it->first.first.c_str(), 
                    it->first.second,
                    it->second);
    }
}

Nice! Some info about [transparent comparators](https://stackoverflow.com/questions/20317413/what-are-transparent-comparators) — Ted Lyngmo, Aug 19 '22 at 18:54

Implement multi-dimensional std::map with std::tuple and view access

2 Answers2