包含按值对地图进行排序的键的向量

Question

我有一个：

std::map<long, std::wstring> fNames;       // ex: fNames[FileReferenceNumber] = L"hello.txt"

由于std::map 有排序的键，但没有值（哈希表unordered_map 甚至没有排序），我想创建一个向量：

std::vector<long> v;

将包含键允许fNames 的迭代按值排序。

例子：如果我们有

9187 => "hello.txt"
13 => “z.txt”
第1777章

那么v 将是：[1777, 9187, 13]，允许迭代 fNames 按值排序：

for (int i = 0; i < v.size(); i++) 
    wcout << fNames[v[i]];     // a.txt, hello.txt, z.txt

有没有办法使用std::sort 创建这个向量v？我不明白怎么做。我应该使用自定义谓词吗？

---

PS：更好的是：是否可以生成一个已排序的std::vector<wstring> w？即每个元素w[0]、w[1] 等都将包含指向fNames 的 wstrings 的“链接”（指针？），但不包含副本（以避免复制字符串数据）？

或者可能是std::vector<wchar_t *> w？

Answer 1

使用指向地图元素的指针向量，并对这些指针进行排序。这使您无需复制即可访问 long 和 wstring。

using value_type = std::map<long, std::wstring>::value_type;
std::vector<value_type*> v;
for (auto& e : fNames)
    v.push_back(&e);
auto compare_by_second = [](value_type* lhs, value_type* rhs) {
    return lhs->second < rhs->second;
};
std::sort(v.begin(), v.end(), compare_by_second);

现在您可以通过v[N]->second 访问wstring 值，通过v[N]->first 访问长值。

C++11 之前的版本

bool compare_by_second(std::pair<const long, std::wstring>* lhs,
                       std::pair<const long, std::wstring>* rhs)
{
    return lhs->second < rhs->second;
}

// in some function
std::map<long, std::wstring> fNames;
...
std::vector<std::pair<const long, std::wstring>*> v;
for (std::map<long, std::wstring>::iterator b = fNames.begin();
     b != fNames.end(); ++b)
{
    v.push_back(&*b);
}
std::sort(v.begin(), v.end(), compare_by_second);

如果您只需要字符串，而不需要 long，那么您可以只使用指向字符串的指针向量。

bool deref_compare(std::wstring* lhs, std::wstring* rhs)
{
    return *lhs < *rhs;
}

// in some function
std::map<long, std::wstring> fNames;
...
std::vector<std::wstring*> v;
for (std::map<long, std::wstring>::iterator b = fNames.begin();
     b != fNames.end(); ++b)
{
    v.push_back(&b->second);
}
std::sort(v.begin(), v.end(), deref_compare);

Answer 2

PS：更好的是：是否有可能制作一个 std::vector<wstring> w 排序？即每个元素w[0]、w[1] 等。 将包含指向fNames 的wstrings 的“链接”（指针？），但不包含副本 （避免重复字符串数据）？

vector<wstring> 将包含重复的字符串（因为 CoW - 写入时复制 - 自 C++11 以来，std::[w]string 已被禁止）。如果你想使用const wchar_t* 来避免字符串重复，你可以这样做：

vector<const wchar_t*> sortedFilenames;

// Reserve room in the vector, since we know how many strings to add
sortedFilenames.reserve(fNames.size());

// Add string pointers from map to vector
for (const auto& e : fNames) {
    // Avoid duplicates using const wchar_t*
    sortedFilenames.push_back(e.second.c_str());
}

// Sort the string vector
sort(begin(sortedFilenames), end(sortedFilenames), 
    [](const auto& p1, const auto& p2) {
        // Use whatever sorting rule you need here...
        return wcscmp(p1, p2) < 0;
    }
); 

---

编辑根据您的评论，您也可以使用vector<const wstring*>，例如：

vector<const wstring*> sortedFilenames;

// Reserve room in the vector, since we know how many strings to add
sortedFilenames.reserve(fNames.size());

// Add string pointers from map to vector
for (const auto& e : fNames) {
    sortedFilenames.push_back(&(e.second));
}

// Sort the string vector
sort(begin(sortedFilenames), end(sortedFilenames),
    [](const auto& p1, const auto& p2) {
        return (*p1) < (*p2); // or whatever sorting rule...
    }
); 

Answer 3

我将在c++14 中解决这个问题，因为它比c++11 或c++03 更简单，并且每个主要的编译器供应商都有足够的支持来编译：

制作一个指向字符串的向量并保留足够的空间（出于效率原因）。

std::vector<std::wstring const*> sorted_strings;
sorted_strings.reserve(fNames.size());

填充指针：

for (auto& entry:fNames)
  sorted_strings.push_back( &entry.second );

对它们进行排序：

std::sort(
  begin(sorted_strings), end(sorted_strings),
  [](auto* lhs, auto* rhs) { return *lhs < *rhs; }
);

对于键向量：

std::vector<int> sorted_keys;
sorted_keys.reserve(fNames.size());
for (auto&& entry:fNames)
  sorted_strings.push_back( entry.first );
std::sort(
  begin(sorted_keys), end(sorted_keys),
  [&](int lhs, int rhs) { return fNames[lhs] < fNames[rhs]; }
);

在c++17 中，您可以取消.first 和.second：

for (auto&[key, value]:fNames)
  sorted_strings.push_back( &value );

使用结构化绑定。