您的代码没有意义。例如，以下声明的含义

string strings[max];

还不清楚。
并且为了找到一个段落的句子中的最大单词数，不需要根据单词数对句子本身进行排序。
如果我没有理解错的话，你需要的是类似下面这样的东西。

#include <iostream>
#include <sstream>
#include <iterator>

int main() 
{
    std::string s;
    
    std::cout << "Enter a paragraph of sentences: ";
    
    std::getline( std::cin, s );
    
    size_t max_words = 0;
    
    std::istringstream is( s );
    std::string sentence;
    
    while ( std::getline( is, sentence, '.' ) )
    {
        std::istringstream iss( sentence );
    
        auto n = std::distance( std::istream_iterator<std::string>( iss ), 
                                std::istream_iterator<std::string>() );

        if ( max_words < n ) max_words = n;                             
    }
    
    std::cout << "The maximum number of words in sentences is " 
              << max_words <<  '\n';
    
    return 0;
}

如果要进入段落

Here is a paragraph. It contains several sentences. For example, how to use string streams.

则输出将为

The maximum number of words in sentences is 7

如果你还不熟悉字符串流，那么你可以使用成员函数find，find_first_of，find_first_not_of和类型为std::string的对象来将字符串拆分成句子，并计算句子中的单词数。

你的用例听起来像是一个约简。本质上你可以有一个状态机（解析器），当它遇到单词和句子分隔符时，它会遍历字符串并更新一些状态（例如计数器）。应该特别注意极端情况，例如当有连续的多个空格或〉1个连续的句号（.）时。处理这些情况的约简如下所示：

int max_words_in(std::string const& str)
{
    // p is the current and max word count.
    auto parser = [in_space = false] (std::pair<int, int> p, char c) mutable {
        switch (c) {
        case '.': // Sentence ends.
            if (!in_space && p.second <= p.first) p.second = p.first + 1;
            p.first = 0;
            in_space = true;
            break;
        case ' ': // Word ends.
            if (!in_space) ++p.first;
            in_space = true;
            break;
        default: // Other character encountered.
            in_space = false;
        }
        return p; // Return the updated accumulation value.
    };

    return std::accumulate(
        str.begin(), str.end(), std::make_pair(0, 0), parser).second;
}

Demo
棘手的是如何处理退化的情况，例如，"This is a , ,tricky .. .. string to count"的输出应该是什么，其中不同类型的分隔符以任意方式交替。解析逻辑的状态机实现允许您轻松地调整解决方案（例如，您可以向解析器传递一个“忽略列表”，并更新默认情况，以便在c属于该列表时不重置in_space变量）。

vector<string> split(string str, char seperator)  // custom split() function
{
    size_t i = 0;
    size_t seperator_pos = 0;

    vector<string> sentences;
    int word_count = 0;

    for (; i < str.size(); i++)
    {
        if (str[i] == seperator)
        {
            i++;
            sentences.push_back(str.substr(seperator_pos, i - seperator_pos));
            seperator_pos = i;
        }
    }

    if (str[str.size() - 1] != seperator)
    {
        sentences.push_back(str.substr(seperator_pos + 1, str.size() - seperator_pos));
    }

    return sentences;
}

JavaScript解决方案

var mostWordsFound = function(sentences) {
    let result = 0;

    sentences.forEach((item) => {
        length = item.split(' ').length
        result = result > length ? result : length;
    })

    return result;
};