在字符串中查找多个子字符串时遇到问题

Question

I am trying to write a program that compares two strings (string and substring) and incitements each time the substring is found within the string. However, using the standard:

if(str.find(substr) != string::npos)
{
count++;
}

I run into the problem that if the substring appears multiple times in the string it only increments once. So if the string is "test test test test" and the substring is "test" count only ends up being 1 instead of 4.

What would be the best way to fix this?

*Notes for context:

1) At one point I was checking the string character by character to see if they matched, but had to scrap that when I ran into issues when some words had smaller words in them.

Example: 'is' would get picked up inside the word 'this', etc

2)The larger program that this is for accepts two vectors. The first vector has a string for each element being sentences the user get to type in (acting at the main string in the example above). And the second vector has each word from all the sentences entered into the first vector (acting as the substring in the example above). Not sure if that bit matters or not, but figured I would throw it in there

Example:

vector<string> str {this is line one, this is line two, this is line three};
vector<string> substr {is, line, one, this, three, two};

3) I'm thinking if there was some way of doing the opposite of !=string::npos would work, but not sure if that even exist.

Answer 1

You need a loop to find all of the occurances of a substring in a given string.

However, since you want to differentiate substrings that are whole words from substrings in larger words, you need to parse the string to determine the whole words before you compare them.

You can use std::string::find_first_of() and std::string::find_first_not_of() to find the beginning and ending indexes of each whole word between desired delimiters (whitespace, punctuation, etc). You can use std::string::compare() to compare a substring between those two indexes to your desired substring. For example:

#include <string>

const std::string delims = ",. ";

size_t countWord(const std::string &str, const std::string &word)
{
    std::string::size_type start = 0, end;
    size_t count = 0;

    while ((start = str.find_first_not_of(delims, start)) != std::string::npos)
    {
        end = str.find_first_of(delims, start+1);
        if (end == std::string::npos)
        {
            if (str.compare(start, str.size()-start, word) == 0)
                ++count;

            break;
        }

        if (str.compare(start, end-start, word) == 0)
            ++count;

        start = end + 1;
    }

    return count;
}

Alternatively, you can extract the whole words into a std::vector and then use std::count() to count how many elements match the substring. For example:

#include <string>
#include <vector>
#include <algorithm>

const std::string delims = ",. ";

size_t countWord(const std::string &str, const std::string &word)
{
    std::vector<std::string> vec;
    std::string::size_type start = 0, end;

    while ((start = str.find_first_not_of(delims, start)) != string::npos)
    {
        end = str.find_first_of(delims, start+1);
        if (end == std::string::npos)
        {
            vec.push_back(str.substr(start));
            break;
        }

        vec.push_back(str.substr(start, end-start));

        start = end + 1;
    }

    return std::count(vec.begin(), vec.end(), word);
}