子集 std：：映射到预定义长度的 std：：vector<std：：map>

subset std::map into std::vector<std::map> of predefined length

本文关键字：std lt gt vector map 映射 预定义 子集      更新时间：2024-05-09

我正在尝试将std::map<string,string>子集为一个映射向量，每个映射都有预定义的长度+剩余。我正在尝试遵循此链接中找到的解决方案。这里的问题是，我不想把地图分成两个部分，而是分成大小相等的n个部分+其余部分

#include <iostream>
#include <string>
#include <vector>
#include <string>
#include <map>
int main(){
using namespace std::string_literals;
auto code = std::map<std::string, std::string>{
{"Red"s, "Red"s},
{"Blue"s, "Blue"s},
{"Green"s, "Green"s},
{"Fuchsia"s, "Fuchsia"s},
{"Mauve"s, "Mauve"s},
{ "Gamboge"s, "Gamboge"s },
{"Vermillion"s, "Vermillion"s}
};

std::vector<std::map<std::string,std::string>> subsetCode;
auto it = code.begin();
auto bt = code.begin();
for (size_t i = 0; i < code.size(); i += 2)
{
auto last = std::min(code.size(), i + 2);

std::advance(it, last);
std::advance(bt, last-2);
subsetCode.push_back(std::map{
std::make_move_iterator(bt),
std::make_move_iterator(it)});
}

for (int i = 0; i < subsetCode.size(); i++) {
for (auto [key, value]: subsetCode[i]){
std::cout << key << ":" << value << " ";
}
std::cout << " " << std::endl;
}
return 1;
}

我想我一直在为下界移动迭代器。

IMHO"其余部分"的定义很差，因为(例如(将20个元素拆分为11个部分会产生10个部分，每个部分有1个元素，而"其余"有10个元素，如果拆分应该是一致的，这(有点(很难看。相反，我会使用9个部分，每个部分有2个元素，然后使用2个"支架"，每个部分都有1个元素。但这只是一个(早期的(旁注；你可以随意调整。

重要的部分可能是迭代器。好吧，因为您要从同一类型的map中移除元素并将元素插入其中，所以最好的选择是extract()及其对应的insert()，即占用节点的重载。这样做的美妙之处在于，在map中使用的类型在这种情况下根本不需要支持移动语义；整个节点仍然存在，因此不需要移动任何东西。这里也不涉及move_iterator——如果我们取消对迭代器的引用(我们不这样做(，那么只有才重要

首先，让我们定义任何map类类型和任意vector类类型的map分裂(节点转移(，因为我们可以：

template<template<typename ... S> class R,
template<typename ... A> class C,
typename I,
typename ... S, typename ... A>
void
transfer_segments(C<A...> &source, I &it,
size_t n_segs, const size_t seg_size,
R<C<A...>, S...> &sink) {
for (; n_segs; --n_segs) {
auto &seg{sink.emplace_back()};
for (size_t i{0}; i < seg_size; ++i)
seg.insert(source.extract(it++));
}
}
template<template<typename ... S> class R,
template<typename ... A> class C,
typename ... S, typename ... A>
void
split_container(C<A...> &&source, const size_t n_segs,
R<C<A...>, S...> &sink) {
const size_t seg_leftover{source.size() % n_segs};
const size_t seg_size{source.size() / n_segs};
auto it{source.begin()};
transfer_segments(source, it, seg_leftover, seg_size + 1, sink);
transfer_segments(source, it, n_segs - seg_leftover, seg_size, sink);
}

使用C++20概念，这些模板可以获得(非常需要的(额外的类型安全性，但为了简洁起见，这一点被省略了。接下来，我们可以在您的数据和类型上测试解决方案：

#include <iostream>
#include <map>
#include <string>
#include <vector>
namespace { /* ... magic templates from above go here ... */ }
int main() {
static const auto get_map{
[]() -> std::map<std::string, std::string> {
using namespace std::string_literals;
return {{"Red"s, "Red"s},
{"Blue"s, "Blue"s},
{"Green"s, "Green"s},
{"Fuchsia"s, "Fuchsia"s},
{"Mauve"s, "Mauve"s},
{"Gamboge"s, "Gamboge"s},
{"Vermillion"s, "Vermillion"s}};
}};
for (size_t n_segs{1}; n_segs <= 7; ++n_segs) {
std::cout << n_segs << ": {n";
std::vector<std::map<std::string, std::string>> segs;
split_container(get_map(), n_segs, segs);
for (const auto &seg : segs) {
std::cout << "     (";
for (const auto &[k, v] : seg)
std::cout << " [" << k << ':' << v << ']';
std::cout << " )n";
}
std::cout << "   }n";
}
}

输出为：

1: {
( [Blue:Blue] [Fuchsia:Fuchsia] [Gamboge:Gamboge] [Green:Green] [Mauve:Mauve] [Red:Red] [Vermillion:Vermillion] )
}
2: {
( [Blue:Blue] [Fuchsia:Fuchsia] [Gamboge:Gamboge] [Green:Green] )
( [Mauve:Mauve] [Red:Red] [Vermillion:Vermillion] )
}
3: {
( [Blue:Blue] [Fuchsia:Fuchsia] [Gamboge:Gamboge] )
( [Green:Green] [Mauve:Mauve] )
( [Red:Red] [Vermillion:Vermillion] )
}
4: {
( [Blue:Blue] [Fuchsia:Fuchsia] )
( [Gamboge:Gamboge] [Green:Green] )
( [Mauve:Mauve] [Red:Red] )
( [Vermillion:Vermillion] )
}
5: {
( [Blue:Blue] [Fuchsia:Fuchsia] )
( [Gamboge:Gamboge] [Green:Green] )
( [Mauve:Mauve] )
( [Red:Red] )
( [Vermillion:Vermillion] )
}
6: {
( [Blue:Blue] [Fuchsia:Fuchsia] )
( [Gamboge:Gamboge] )
( [Green:Green] )
( [Mauve:Mauve] )
( [Red:Red] )
( [Vermillion:Vermillion] )
}
7: {
( [Blue:Blue] )
( [Fuchsia:Fuchsia] )
( [Gamboge:Gamboge] )
( [Green:Green] )
( [Mauve:Mauve] )
( [Red:Red] )
( [Vermillion:Vermillion] )
}

当涉及到一种不同的划分为统一的部分和"其余部分"时，算法可以很容易地进行调整。

如果你想将映射子集为n个部分，子映射的大小等于map.size((/n，听说是一个o(n(解决方案：

#include <iostream>
#include <string>
#include <vector>
#include <map>
int main() {
auto code = std::map<std::string, std::string>{
{"Red", "Red"},
{"Blue", "Blue"},
{"Green", "Green"},
{"Fuchsia", "Fuchsia"},
{"Mauve", "Mauve"},
{ "Gamboge", "Gamboge" },
{"Vermillion", "Vermillion"}
};

// assume you want each part size is 2.
constexpr int subSize = 2; 
std::vector<std::map<std::string, std::string>> subsetCodes;    
std::map<std::string, std::string> subset;
for (auto& item : code) {
subset.insert({item.first, std::move(item.second)});
while (subset.size() == subSize) {
subsetCodes.push_back(std::move(subset));
subset = std::map<std::string, std::string>();
}
}
if (!subset.empty())
subsetCodes.push_back(std::move(subset));
code.clear();

for (int i = 0; i < subsetCodes.size(); i++) {
for (auto [key, value]: subsetCodes[i]){
std::cout << key << ":" << value << " ";
}
std::cout << " " << std::endl;
}
}
相关文章：