C++ 我需要这个程序先打印出数量最大的单词数。然后将列表限制为插入的前20个单词 #包括 #包括 #包括 #包括 #包括 #包括 //#包括 使用名称空间std； 无效打印频率（字符串str） { 地图频率； 字串=”； 对于（int i=0；i

参考：

---

我想通过使用标准C++库中的现有算法来向大家展示一种“更现代”的C++方法。 对于这类问题，我们还将使用标准的解决方案。因为，基本的基本问题是，如何对关联容器进行排序，如

std:：map

或

std:：unordered_map

，按其值排序，而不是按其键排序

当然，这些容器不可能按值排序。原因：

• std:：map

  的基本属性是按键值排序
• 而且，

  std:：unordered_映射

  ，具有逻辑属性，即它是unordered，此外，还具有排序函数所需的“ForwardIterator”而不是“RandomAccessIterator”

答案和标准解决方案是，将数据放入另一个容器中，并对其进行排序

现在我将向您展示代码。该代码包含“modern-C++”风格的函数“printFrequency”。稍后，我将逐行详细解释该代码

#include <bits/stdc++.h>
#include <map>
#include <string>
#include <algorithm>
#include <set>
#include <iostream>
//#include <functional>
using namespace std;

void printFrequency(string str)
{
   map<string, int> freq;
   string word = "";
  
   for (int i = 0; i < str.size(); i++)
      {
       if (str[i] == ' ') 
          {
            if (freq.find(word) == freq.end()) 
              {
                 freq.insert(make_pair(word, 1));
                  word = "";
              }
             else 
              {
                freq[word]++;
                word = "";
              }
           }
         else
           word += str[i];
       }
      if (freq.find(word) == freq.end())
         freq.insert(make_pair(word, 1));
      else
          freq[word]++;
     
    for (map<string, int>::iterator itr = freq.begin(); itr != freq.end(); ++itr) 
      {
       cout << setw(20)<<itr->first <<setw(20)<< itr->second<< endl;
      } 
};

int main()
{
string str = " ";
cout << "Enter your string: ";
getline(cin, str);
cout << endl;
printFrequency(str);
return 0;
}

#包括
#包括
#包括

在循环体中，我们使用
std:：map
的索引运算符。它将首先创建一个默认计数为0的新词（如果还没有这样的条目），或者，它将搜索现有条目并找到它。在任何情况下，都会返回对单词值的引用。该值将递增。因此，我们计算单词的出现次数


现在我们将定义一个类型为
std:：vector
的变量“countedWords”。我们将使用它的“range”-构造函数。请参阅，构造函数编号5。这将使用
std:：map
的内容定义和初始化变量。接下来，我们将对
std:：vector
进行排序，这将起作用，因为我们的自定义数据类型具有小于运算符

基本上现在一切都完成了，只需要输出。我们希望将一定数量的结果复制到
std:：cout
。但可能是
std:：vector
中的元素比我们希望输出的元素少。因此，我们将取
std:：vector
中元素的最小值和请求的数量，然后继续h那

对于输出，我们将使用
std：：copy_n
。它将以
std：：vector
中的元素作为源，并在
std：：ostream_迭代器的帮助下将它们发送到
std：：cout
中。
std：：ostream_迭代器
将简单地为
std：：vec中的元素调用上述定义的插入器操作符tor

最后，我们定义了一个简单的“main”函数作为驱动程序代码，并使用一些测试字符串作为输入数据

其结果是一个紧凑且易于理解的函数

当然，还有数以百万计的其他可能实现

如果有任何问题，我很乐意回答。
使用命名空间std；
和
都是不好的做法。请在此网站上搜索。
#include <iostream>
#include <string>
#include <algorithm>
#include <regex>
#include <map>
#include <vector>
#include <utility>
#include <iomanip>

// Some test data
std::string testString
{ R"(Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy 
eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam 
voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet 
clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.
Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy 
eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. 
At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, 
no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, 
consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et 
dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo 
dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est 
Lorem ipsum dolor sit amet.)" };

// We want to output this number of lines
constexpr size_t NumberOfOutputLines = 20U;

// Some abbreviation for our pair to store a word and its associated counter
using CounterType = std::pair<std::string, size_t>;

// Enhance our pair with 2 new functionalities: Output and comparison (for sorting)
struct CTO : public CounterType {
    friend std::ostream& operator << (std::ostream& os, const CTO& co) {
        return os << std::setw(30) << co.first << " --> " << co.second << '\n';
    }
    friend bool operator < (const CTO& p1, const CTO& p2) { return p2.second < p1.second; }
};

// Regex Helpers
// Regex to find a word
static const std::regex reWord{ R"(\w+)" };
// Result of search for one word in the string
static std::smatch smWord;


void printFrequency(std::string& data) {

    // Here we will store the result. The word and the associated "count" 
    std::map<std::string, size_t> counter{};

    // Iterate over all words in the string with a simple for loop and increment counter
    for (std::string s{ data }; std::regex_search(s, smWord, reWord); s = smWord.suffix())
        counter[smWord[0]]++;

    // Copy result into a vector and sort it
    std::vector<CTO> countedWords(counter.begin(), counter.end());
    std::sort(countedWords.begin(), countedWords.end());

    // Handle special case, where there are less counts available than expected
    const size_t oCount{ std::min(countedWords.size(),NumberOfOutputLines) };

    // Output sorted result
    std::copy_n(countedWords.begin(), oCount, std::ostream_iterator<CTO>(std::cout));
}


// Driver code
int main() {
    printFrequency(testString);
    return 0;
}