在成對的多圖中查找最大/最小鍵 <Class object, enum> ，使用多圖算法（std :: minmax_element）？

Question

我有這個程序，在這里我將成對的Class Object +枚舉放在一個多圖中。 類對象的成員類型為int filesize。 我想在多重地圖中找到最大和最小的鍵。

我通過制作3個迭代器來完成此任務，將每個對象與下一個對象進行比較，如果對象較小（或更大，取決於我搜索的對象），則會將其分配給第3個迭代器。 之后，我只打印出第三個迭代器。 還有其他優雅的方法嗎？ 我知道這可行，但是我敢肯定還有另一種方法-我似乎找不到它。

這是我的最大文件功能：

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;
    }

第二個類的構造函數，在這里我制作了多圖，並用一對其他類對象+枚舉（從文件中讀取）填充它：

 CDirectory (string n) {
              fp.open (n, ios::in);
              string dirName, fileName,  fType;
              int fileSize;
              fp >> dirName;
              m_strDirectory = dirName;
              while (fp >> fileName >> fileSize >> fType) {
                      CFile obj (fileName, fileSize);
                       if (fType == "Archive")
                  filetype = Filetype::Archive;
              else if (fType == "Hidden")
                  filetype = Filetype::Hidden;
              else if (fType == "ReadOnly")
                  filetype = Filetype::ReadOnly;
              else if (fType == "System")
                  filetype = Filetype::System;
              else
                  filetype = Filetype::FileNotSupported;
              m_DirectoryMap.insert(pair<CFile, Filetype>(CFile(obj.getFileName(), obj.getFileSize()), Filetype(filetype)));
              }
              multimap<CFile, Filetype>::iterator p = m_DirectoryMap.begin();
              while ( p != m_DirectoryMap.end()) {
                cout << endl << p->first.getFileName() << '\t' << p->first.getFileSize() << '\t' << p->second << endl;
                ++p;
              }
    }   

第一個類（哪些對象是我的多重映射中的鍵）：

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& obj) {
        return ( m_size < obj.m_size );
    }
    bool operator== (const CFile& obj) {
        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) {
        if ( obj1.m_size > obj2.m_size )
            return true;
        else
            return false;
    }
};

Answer 1

std::minmax_element允許您傳遞比較器以在查看對象時使用，因此您可以執行以下操作：

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

p將成為您集合中的一對迭代器，因此您可以（例如）使用以下命令將它們打印出來：

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

但是，仔細查看后，您似乎仍然使用size成員作為文件的順序。 在這種情況下，您可以使用以下事實：已經根據您關注的數據對地圖進行了排序，因此您可以使用：

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";
}