C++ 检查STL向量中某个位置的元素是否存在（已设置）

我正在写一个以随机字符串作为输入的算法。我需要输出遇到的最大长度，以及有多少单词具有该特定长度。是的，我知道我可以使用不同的方法，但我想将每个字符串存储在一个v[它的长度]中，如果有多个字符串具有相同的长度，那么我会增加u[相同的长度]，然后只输出这些值。如何检查v[length]是否已设置

对不起，英语可能不好

#include <iostream>
#include <vector>
#include <string>

using namespace std;

typedef unsigned short us;
typedef vector<string> vstr;
typedef vector<us> vus;

int main()
{
    string str;
    vstr v;
    vus u(50, 1);
    us len;

    while (cin >> str && str != "0")
    {
        len = str.length();

        //if there is an element set at v[len] then ++u[len] otherwise v[len] = str;
    }

    //bunch of other code

    return 0;
}

#包括
#包括
#包括
使用名称空间std；
typedef无符号短us；
矢量vstr；
typedef向量vus；
int main（）
{
字符串str；
vstr v；
vusu（50,1）；
美国莱恩；
而（cin>>str&&str！=“0”）
{
len=str.length（）；
//如果在v[len]处设置了一个元素，则++u[len]，否则v[len]=str；
}
//一堆其他代码
返回0；
}

除非您事先知道任何可能字符串的最大长度，否则这将不起作用。我们称之为最大X。然后你可以构造一个X int的向量，初始化为0，然后使用下标操作符增加你需要的向量

std::vector<int> counts(X, 0); // X ints, initialized to 0
for (const string str : v) {
    int length = str.size();
    try {
        counts.at(length)++;
    } catch (const std::out_of_range& oor) {
        // Your professor lied to you!
    }
}

---

counts[length]将在[length]处创建元素（如果该元素不存在），并在该元素已存在时递增该元素。

除非您事先知道任何可能字符串的最大长度，否则此操作将无效。我们称之为最大X。然后你可以构造一个X int的向量，初始化为0，然后使用下标操作符增加你需要的向量

std::vector<int> counts(X, 0); // X ints, initialized to 0
for (const string str : v) {
    int length = str.size();
    try {
        counts.at(length)++;
    } catch (const std::out_of_range& oor) {
        // Your professor lied to you!
    }
}

---

计数[length]将在[length]处创建元素（如果该元素不存在），并在该元素已存在时递增。

A

std:：vector v

的长度由

v.size（）

给定，并且范围

[0，v.size（））

中的所有元素都存在

因此，如果

v.size（）>n

您可以通过检查向量的长度来测试它，或者使用

v.at（n）

而不是

v[n]

来访问元素，因为

at（）

函数将在元素不存在时抛出异常（即，如果长度至少不是

n

）

---

事实上，a

std:：vector

在每个索引处都包含一个元素，其长度不超过其长度，这意味着它不是a的有效表示形式。使用标准容器之一表示稀疏数组时，最好使用

std:：map

，因为它不要求元素具有连续键。

a

std:：vector v

具有由

v.size（）

给出的长度，以及范围

[0，v.size（））

中的所有元素都存在

因此，如果

v.size（）>n

您可以通过检查向量的长度来测试它，或者使用

v.at（n）

而不是

v[n]

来访问元素，因为

at（）

函数将在元素不存在时抛出异常（即，如果长度至少不是

n

）

事实上，一个

std:：vector

在每个索引处都包含一个元素，直到其长度为止，这意味着用一个标准容器表示稀疏数组不是一种有效的表示方法。最好使用

std:：map

，因为它不要求元素具有连续键

是的，我知道我可以使用不同的方法

老实说，我真的相信你最好采用另一种方法

您根本不需要长度向量，也不需要映射，也不需要字符串向量，除非您也想显示这些字符串（这里，我假设您确实需要）。最后，您甚至不需要知道这些字符串的最大长度：

#include <iostream>
#include <vector>
#include <string>

int main()
{
    std::vector<std::string> words;

    std::string::size_type maxLength = 0;
    std::string str;
    while (std::cin >> str)
    {
        auto len = str.length();
        if (len == maxLength)
        {
            words.push_back(str);
        }
        else if (len > maxLength)
        {
            maxLength = len;

            words.clear();
            words.push_back(str);
        }
    }

    std::cout << "Max length: " << maxLength << std::endl;
    std::cout << "# of words with max length: " << words.size() << std::endl;
    std::cout << "Words with max length: " << std::endl;
    for (auto const& s : words) { std::cout << s << std::endl; }

    return 0;
}

#包括
#包括
#包括
int main（）
{
向量词；
std:：string:：size\u type maxLength=0；
std：：字符串str；
而（std:：cin>>str）
{
自动长度=长度（）；
if（len==maxLength）
{
词。推回（str）；
}
else if（len>maxLength）
{
maxLength=len；
单词。清除（）；
词。推回（str）；
}
}
标准：：cout
是的，我知道我可以使用不同的方法

老实说，我真的相信你最好采用另一种方法

您根本不需要长度向量，也不需要映射，也不需要字符串向量，除非您也想显示这些字符串（这里，我假设您确实需要）。最后，您甚至不需要知道这些字符串的最大长度：

#include <iostream>
#include <vector>
#include <string>

int main()
{
    std::vector<std::string> words;

    std::string::size_type maxLength = 0;
    std::string str;
    while (std::cin >> str)
    {
        auto len = str.length();
        if (len == maxLength)
        {
            words.push_back(str);
        }
        else if (len > maxLength)
        {
            maxLength = len;

            words.clear();
            words.push_back(str);
        }
    }

    std::cout << "Max length: " << maxLength << std::endl;
    std::cout << "# of words with max length: " << words.size() << std::endl;
    std::cout << "Words with max length: " << std::endl;
    for (auto const& s : words) { std::cout << s << std::endl; }

    return 0;
}

#包括
#包括
#包括
int main（）
{
向量词；
std:：string:：size\u type maxLength=0；
std：：字符串str；
而（std:：cin>>str）
{
自动长度=长度（）；
if（len==maxLength）
{
词。推回（str）；
}
else if（len>maxLength）
{
maxLength=len；
单词。清除（）；
词。推回（str）；
}
}
事实上，我知道任何可能给定字符串的最大长度是20。这实际上是一个简单的家庭作业，上面写着“最多20个字符的随机字符串”。如果我有这些信息，我将如何继续？是的，我现在看到了。你能解释一下这行吗？“（string str:v）”。我不理解迭代，它是循环的
范围。它迭代
v
中的每个元素，并将
v
中的每个元素作为标识符
str
传递到循环中。事实上，我知道任何可能给定字符串的最大长度，它是20。这实际上是一个简单的家庭作业，我知道t表示“最多20个字符的随机字符串”。如果我有这些信息，我将如何进行？是的，我现在看到了。你能解释一下这行吗？“for（string str:v）”。我不理解迭代的范围是<