Question

所以我需要检查Token中是否存在特定的子字符串，如果存在，则将变量int 1添加1。

字符串输入=＆＃34; aaabbb＃abbb＃＆＃34;

标记化输入

tokens =

abbba 
abbbb

a存在于两个令牌中，因此输出应为

a:2

但是我的代码输出

a:1
a:1

如果只有一个令牌，则打印

a:1

如果没有令牌如下：

bbb #bbb＃

它没有正确输出任何内容。

如何让我的代码输出

a:2

而不是

a:1
a:1

---这是我的代码

的main.cpp

#include "Tokenizer.h"
#include <string>
#include <iostream>
#include <algorithm>
using std::string;
using std::cout;
using std::endl;

int countSubstring(const std::string& str, const std::string& sub)
{
    if (sub.length() == 0) return 0;
    int count = 0;
    for (size_t offset = str.find(sub); offset != std::string::npos;
     offset = str.find(sub, offset + sub.length()))
    {
        ++count;
    }
    return count;
}
int main(int argc, char* argv[])
{
    // instanciate Tokenizer class
    Tokenizer str;
    string token;
    string input;
    getline(std::cin , input);
    // set source string with delimiter "#" 
    str.set(input, "#");

    // Tokenizer::next() returns a next available token from source string
    // If it reaches EOS, it returns zero-length string, "".
    while((token = str.next()) != "")
    {
        int a = 0;
        if(countSubstring(token,"a") >= 1)
        { 
           a++;
        }

         cout << "a: " << a << endl;
    }
    cout << endl;
    return 0;
}

Tokenizer.h

#ifndef TOKENIZER_H
#define TOKENIZER_H

#include <string>
#include <vector>

// default delimiter string (space, tab, newline, carriage return, form feed)
const std::string DEFAULT_DELIMITER = "";

class Tokenizer
{
public:
    // ctor/dtor
    Tokenizer();
    Tokenizer(const std::string& str, const std::string& delimiter=DEFAULT_DELIMITER);
    ~Tokenizer();

    // set string and delimiter
    void set(const std::string& str, const std::string& delimiter=DEFAULT_DELIMITER);
    void setString(const std::string& str);             // set source string only
    void setDelimiter(const std::string& delimiter);    // set delimiter string only

    std::string next();                                 // return the next token, return "" if it ends

    std::vector<std::string> split();                   // return array of tokens from current cursor

protected:


private:
    void skipDelimiter();                               // ignore leading delimiters
    bool isDelimiter(char c);                           // check if the current char is delimiter

    std::string buffer;                                 // input string
    std::string token;                                  // output string
    std::string delimiter;                              // delimiter string
    std::string::const_iterator currPos;                // string iterator pointing the current position

};

#endif // TOKENIZER_H

Tokenizer.cpp

#include "Tokenizer.h"


///////////////////////////////////////////////////////////////////////////////
// constructor
///////////////////////////////////////////////////////////////////////////////
Tokenizer::Tokenizer() : buffer(""), token(""), delimiter(DEFAULT_DELIMITER)
{
    currPos = buffer.begin();
}

Tokenizer::Tokenizer(const std::string& str, const std::string& delimiter) : buffer(str), token(""), delimiter(delimiter)
{
    currPos = buffer.begin();
}



///////////////////////////////////////////////////////////////////////////////
// destructor
///////////////////////////////////////////////////////////////////////////////
Tokenizer::~Tokenizer()
{
}



///////////////////////////////////////////////////////////////////////////////
// reset string buffer, delimiter and the currsor position
///////////////////////////////////////////////////////////////////////////////
void Tokenizer::set(const std::string& str, const std::string& delimiter)
{
    this->buffer = str;
    this->delimiter = delimiter;
    this->currPos = buffer.begin();
}

void Tokenizer::setString(const std::string& str)
{
    this->buffer = str;
    this->currPos = buffer.begin();
}

void Tokenizer::setDelimiter(const std::string& delimiter)
{
    this->delimiter = delimiter;
    this->currPos = buffer.begin();
}



///////////////////////////////////////////////////////////////////////////////
// return the next token
// If cannot find a token anymore, return "".
///////////////////////////////////////////////////////////////////////////////
std::string Tokenizer::next()
{
    if(buffer.size() <= 0) return "";           // skip if buffer is empty

    token.clear();                              // reset token string

    this->skipDelimiter();                      // skip leading delimiters

    // append each char to token string until it meets delimiter
    while(currPos != buffer.end() && !isDelimiter(*currPos))
    {
        token += *currPos;
        ++currPos;
    }
    return token;
}



///////////////////////////////////////////////////////////////////////////////
// skip ang leading delimiters
///////////////////////////////////////////////////////////////////////////////
void Tokenizer::skipDelimiter()
{
    while(currPos != buffer.end() && isDelimiter(*currPos))
        ++currPos;
}



///////////////////////////////////////////////////////////////////////////////
// return true if the current character is delimiter
///////////////////////////////////////////////////////////////////////////////
bool Tokenizer::isDelimiter(char c)
{
    return (delimiter.find(c) != std::string::npos);
}



///////////////////////////////////////////////////////////////////////////////
// split the input string into multiple tokens
// This function scans tokens from the current cursor position.
///////////////////////////////////////////////////////////////////////////////
std::vector<std::string> Tokenizer::split()
{
    std::vector<std::string> tokens;
    std::string token;
    while((token = this->next()) != "")
    {
        tokens.push_back(token);
    }

    return tokens;
}

此外，如果a未出现在令牌中，则不允许打印。

Answer 1

我认为有一段时间会更好。这是我的解决方案：

#include <iostream>
#include <string>

using namespace std;

size_t countSubString(const string& str, const string& sub) {
   size_t ret = 0;
   size_t loc = str.find(sub);
   while (loc != string::npos) {
      ++ret;
      loc = str.find(sub, loc+1);
   }
   return ret;
}

int main() {
   static const char* tokens[] = {"aaa", "aba" };
   for (int i=0; i<2; ++i) {
      cout << tokens[i] << " " << countSubString(tokens[i], "a") << endl;
   }

   return 0;
}

Answer 2

#include <string>
#include <iostream>
int countOccurances( const std::string &token, const std::string &substring )    
{
    const size_t token_len = token.length();
    const size_t substring_len = substring.length();        
    if ( substring_len > token_len ) { return 0; }
        if ( substring_len == token_len ) 
            return ((token.compare(substring) == 0) ?  1 : 0); 

    const size_t range = token_len-substring_len;
    size_t counter = 0;
    for (size_t i=0; i <= range; i++) {
        if ( token.compare(i,substring_len,substring) == 0 )
            ++counter;
    }
    return counter;
}

int main () {
    std::string token = "abbb";
    std::string substring = "a";

    std::cout << "Token " << token << " has " << countOccurances(token,substring) << 
    " occurances of " << substring << std::endl;

    token = "abba";
    substring = "a";

    std::cout << "Token " << token << " has " << countOccurances(token,substring) << 
    " occurances of " << substring << std::endl;

    return 0;
}

Answer 3

代码的核心是这个

    int a = 0;
    if(countSubstring(token,"a") >= 1)
    { 
       a++;
    }

    cout << "a: " << a << endl;

此代码创建一个名为a的变量，并为其赋值0。然后它调用countSubstring并测试返回值是否为>= 1。然后丢弃返回值。

如果上述条件匹配，我们会将a增加1。

然后我们打印a。

上述所有情况都发生在此代码所在的while循环的每次迭代中。

因此，此代码只能打印a: 0或a: 1。

这是一种耻辱，因为您要查找的值是由countSubstring 返回给您的，但您选择丢弃它。

您的代码可以通过以下方式修复：

int count = countSubstring(token, "a"); std::cout << "a: " << count << '\n';

如：

while((token = str.next()) != "") { int count = countSubstring(token, "a"); std::cout << "a: " << count << '\n'; }

如何计算令牌C ++中子字符串的存在次数

3 个答案: