C++ 在成对的多重映射中查找最大/最小键<；类对象，枚举>；，使用多重映射算法（std:：minmax_元素）？

我有一个程序，我把类对象+枚举对放在多重映射中。类对象的成员类型为int filesize。我想在多重贴图中找到最大和最小的关键点

我制作了3个迭代器，将每个对象与下一个对象进行比较，如果它更小（或更大，取决于我搜索的内容），则将其分配给第三个迭代器。之后，我只打印出第三个迭代器。还有其他优雅的方法吗？我知道这是可行的，但我确信还有另一种方法——我就是找不到

以下是我的max文件函数：

void getMaxFile() {
        multimap<CFile, Filetype>::iterator p = m_DirectoryMap.begin();
        multimap<CFile, Filetype>::iterator t = m_DirectoryMap.begin();
        multimap<CFile, Filetype>::iterator x = m_DirectoryMap.begin();
        t++;
        while  (p != m_DirectoryMap.end()) {
                if (p->first.getFileSize() > t->first.getFileSize())
                    x = p;
                ++p, ++t;
        }
        cout << "The largest file is: " << endl << x->first.getFileName()
             << '\t' << x->first.getFileSize() << '\t' << x->second << endl;
    }

void getMaxFile（）{
multimap:：迭代器p=m_DirectoryMap.begin（）；
multimap:：迭代器t=m_DirectoryMap.begin（）；
迭代器x=m_DirectoryMap.begin（）；
t++；
while（p！=m_DirectoryMap.end（））{
如果（p->first.getFileSize（）>t->first.getFileSize（））
x=p；
++p、 ++t；
}
cout>文件大小>>fType）{
cfileobj（文件名、文件大小）；
如果（fType==“存档”）
filetype=filetype:：Archive；
else if（fType==“隐藏”）
filetype=filetype:：Hidden；
else if（fType==“只读”）
filetype=filetype:：ReadOnly；
else if（fType==“系统”）
filetype=filetype:：System；
其他的
filetype=filetype:：FileNotSupported；
m_DirectoryMap.insert（成对（CFile（obj.getFileName（），obj.getFileSize（）），Filetype（Filetype））；
}
multimap:：迭代器p=m_DirectoryMap.begin（）；
while（p！=m_DirectoryMap.end（））{
cout obj2.m_尺寸）
返回true；
其他的
返回false；
}
};

std:：minmax_元素

允许您在查看对象时传递要使用的比较器，因此您可以执行以下操作：

auto p = std::minmax_element(m_directoryMap.begin(), m_directoryMap.end(), 
    [](CFile const &a, CFile const &b) { return a.getFileSize() < b.getFileSize(); });

但是，仔细看，似乎您仍然在使用size成员作为文件的排序。在这种情况下，您可以使用这样一个事实，即地图已经根据您关心的数据进行了排序，因此您可以使用：

std::cout << "Smallest: " << m_directoryMap.begin()->getFileSize() << " bytes\n";
std::cout << "Largest:  " << m_directoryMap.rbegin()->getFileSize() << " bytes\n";

std:：cout obj2.m_size）；
}
};
结构cmp{
布尔运算符（）{
返回a.getFileName（）std:：cout first.getFileSize（）
std:：minmax_元素
允许您在查看对象时传递比较器以使用，因此您可以执行以下操作：

auto p = std::minmax_element(m_directoryMap.begin(), m_directoryMap.end(), 
    [](CFile const &a, CFile const &b) { return a.getFileSize() < b.getFileSize(); });

但是，仔细看，似乎您正在使用大小成员作为文件的排序方式。在这种情况下，您可以使用这样一个事实，即地图已经根据您关心的数据排序，因此您可以使用：

std::cout << "Smallest: " << m_directoryMap.begin()->getFileSize() << " bytes\n";
std::cout << "Largest:  " << m_directoryMap.rbegin()->getFileSize() << " bytes\n";

std:：cout obj2.m_size）；
}
};
结构cmp{
布尔运算符（）{
返回a.getFileName（）std:：cout first.getFileSize（）可能我没有得到它，但是因为映射是按键排序的，所以不会
*being（）
和
*rbegin（）
最小的键是最大的键吗？映射是按键文件名排序的（不是文件大小）.你是怎么做到的？我在这里看到的一切让我相信它会按文件大小排序。映射是如何声明的？我有一个
bool操作符<（CFile obj1，CFile obj2）{return obj1.getFileName（）可能我没有得到它，但因为映射是按关键字wont
*being（）
和
*rbegin（）排序的
最小的是最大的键吗？映射是按键文件名（而不是文件大小）排序的。你是怎么做的？我在这里看到的一切让我相信它会按文件大小排序。映射是如何声明的？我有一个
bool操作符<（CFile obj1，CFile obj2）{return obj1.getFileName（）在
std:：multimap
中没有
front
或
back
。您可以使用
*being（）
和
*rbegin（）
。@hopittyhop:哦，是的，很抱歉--您的比较函数将传递一个
std:：pair
，因此您需要
a.first.getFileSize（）
@hopittyhop:我们似乎在这里兜圈子。首先，你说
对
没有成员
getFileSize
（这是真的——只有成员
第一个
和
第二个
）。如果您得到一个
对
，那么
第一个
成员是
X
，因此要调用
X
的成员函数，您需要调用
a.first.member（）
。另一方面，如果您实际上直接收到
X
，而不是作为
对的成员），然后您只需调用
a.member
@Jerry Coffin:我完全理解并遵循您的逻辑，但不知怎么的，我就是不能让它工作。语法就是不起作用。@Jerry Coffin:这是我整个程序的链接，如果您有时间并且愿意在某个时候检查它的话，中没有
前
或
后
ode>std:：multimap
。你可以使用
*being（）
和
*rbegin（）
。@hopittyhop:哦，是的，
std::cout << "Smallest: " << m_directoryMap.begin()->getFileSize() << " bytes\n";
std::cout << "Largest:  " << m_directoryMap.rbegin()->getFileSize() << " bytes\n";

#include <string>
#include <iostream>
#include <map>
#include <algorithm>

using std::string;
using std::istream;
using std::ostream;

class CFile {
    string m_strFile;
    unsigned int m_size;
public:
    CFile() { m_strFile = ""; m_size = 0; }
    CFile(string name, int size) { m_strFile = name; m_size = size; }
    string getFileName() const { return m_strFile; }
    int getFileSize() const { return m_size; }
    void setFileSize(int size) { m_size = size; }
    bool operator< (CFile const& obj) const {
        return (m_size < obj.m_size);
    }
    bool operator== (const CFile& obj) const {
        return (m_size == obj.m_size);
    }
    friend ostream& operator<< (ostream& ost, const CFile& obj) {
        return ost << obj.m_strFile << obj.m_size;
    }
    friend istream& operator>> (istream& ist, CFile& obj) {
        return ist >> obj.m_strFile >> obj.m_size;
    }
    static bool Greater(const CFile& obj1, const CFile& obj2) {
        return (obj1.m_size > obj2.m_size);
    }
};

struct cmp {
    bool operator()(CFile const &a, CFile const &b) {
        return a.getFileName() < b.getFileName();
    }
};

int main() {
    std::multimap<CFile, int, cmp> files {
        { CFile { "abc", 123 }, 1 },
        { CFile { "cde", 234 }, 2 },
        { CFile { "def", 345 }, 3 }
    };

    auto p = std::minmax_element(files.begin(), files.end(),
        [](auto const &a, auto const &b) { return a.first.getFileSize() < b.first.getFileSize(); });

    std::cout << p.first->first.getFileSize() << "\n";
    std::cout << p.second->first.getFileSize() << "\n";
}